Built with
Alectryon , running Coq+SerAPI v8.14.0+0.14.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 .
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 "_ + _" 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.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.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]
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 "[ 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]
(** Throughout this file, we assume ideal uni-processor schedules ... *)
Require Import prosa.model.processor.ideal.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]
(** ... and the classic (i.e., Liu & Layland) model of readiness
without jitter or self-suspensions, wherein pending jobs are
always ready. *)
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]
(** * 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}.
(** ... 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}.
(** 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.
(** For simplicity, let's define some local names. *)
Let response_time_bounded_by := task_response_time_bound arr_seq sched.
Let number_of_task_arrivals := number_of_task_arrivals arr_seq.
(** Assume that there exists a constant priority_inversion_bound that bounds
the length of any priority inversion experienced by any job of [tsk].
Since we analyze only task [tsk], we ignore the lengths of priority
inversions incurred by any other tasks. *)
Variable priority_inversion_bound : 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 case of search space for EDF we ask whether [task_rbf A ≠ task_rbf (A + ε)]... *)
Definition task_rbf_changes_at (A : duration) := task_rbf A != task_rbf (A + ε).
(** ...or 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: 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.
(** The final search space for EDF is a set of offsets that are less than [L]
and where [task_rbf] or [bound_on_total_hep_workload] changes. *)
Definition is_in_search_space (A : duration) :=
(A < L) && (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
+ (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 + bound_on_total_hep_workload A R.
(** ** Filling Out Hypothesis Of Abstract RTA Theorem *)
(** In this section we prove that all hypotheses necessary
to use the abstract theorem are satisfied. *)
Section FillingOutHypothesesOfAbstractRTATheorem .
(** First, we prove that in the instantiation of interference and interfering workload,
we really take into account everything that can interfere with [tsk]'s jobs, and thus,
the scheduler satisfies the abstract notion of work conserving schedule. *)
Lemma instantiated_i_and_w_are_coherent_with_schedule :
work_conserving_ab tsk interference interfering_workload.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
work_conserving_ab tsk interference
interfering_workload
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
work_conserving_ab tsk interference
interfering_workload
unfold EDF in *.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
work_conserving_ab tsk interference
interfering_workload
intros j t1 t2 t ARR TSK POS BUSY NEQ; split ; intros HYP;
[move : HYP => /negP | rewrite scheduled_at_def in HYP; move : HYP => /eqP HYP ].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2
~~ interference j t -> scheduled_at sched j t
move : H_sched_valid => [CARR MBR].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
~~ interference j t -> scheduled_at sched j t
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
~~ interference j t -> scheduled_at sched j t
rewrite negb_or /is_priority_inversion /is_priority_inversion
/is_interference_from_another_hep_job.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
~~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end &&
~~
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end -> scheduled_at sched j t
move => /andP [HYP1 HYP2].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched HYP1 : ~~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end HYP2 : ~~
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end
scheduled_at sched j t
ideal_proc_model_sched_case_analysis_eq sched t jo. Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched HYP1 : ~~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end HYP2 : ~~
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end Idle : is_idle sched t EqIdle : sched t = None
scheduled_at sched j t
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched HYP1 : ~~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end HYP2 : ~~
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end Idle : is_idle sched t EqIdle : sched t = None
scheduled_at sched j t
exfalso ; clear HYP1 HYP2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched Idle : is_idle sched t EqIdle : sched t = None
False
eapply instantiated_busy_interval_equivalent_busy_interval in BUSY; eauto 2 with basic_facts.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched Idle : is_idle sched t EqIdle : sched t = None
False
move : BUSY => [PREF _].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jNEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched Idle : is_idle sched t EqIdle : sched t = None PREF : busy_interval_prefix arr_seq sched j t1 t2
False
by eapply not_quiet_implies_not_idle; eauto 2 with basic_facts. } Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched HYP1 : ~~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end HYP2 : ~~
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end jo : Job Sched_jo : scheduled_at sched jo t EqSched_jo : #|[pred x |
let
'FiniteQuant .Quantified F :=
FiniteQuant.ex (T:=Core)
(, scheduled_on jo (sched t) x) x
x in F]| <> 0
scheduled_at sched j t
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched HYP1 : ~~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end HYP2 : ~~
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end jo : Job Sched_jo : scheduled_at sched jo t EqSched_jo : #|[pred x |
let
'FiniteQuant .Quantified F :=
FiniteQuant.ex (T:=Core)
(, scheduled_on jo (sched t) x) x
x in F]| <> 0
scheduled_at sched j t
clear EqSched_jo; move : Sched_jo; rewrite scheduled_at_def; move => /eqP EqSched_jo.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched HYP1 : ~~
match sched t with
| Some jlp => ~~ hep_job jlp j
| None => false
end HYP2 : ~~
match sched t with
| Some jhp => hep_job jhp j && (jhp != j)
| None => false
end jo : Job EqSched_jo : sched t = Some jo
scheduled_at sched j t
rewrite EqSched_jo in HYP1, HYP2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo HYP1 : ~~ ~~ hep_job jo j HYP2 : ~~ (hep_job jo j && (jo != j))
scheduled_at sched j t
move : HYP1 HYP2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo
~~ ~~ hep_job jo j ->
~~ (hep_job jo j && (jo != j)) ->
scheduled_at sched j t
rewrite Bool.negb_involutive negb_and.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo
hep_job jo j ->
~~ hep_job jo j || ~~ (jo != j) ->
scheduled_at sched j t
move => HYP1 /orP [/negP HYP2| /eqP HYP2].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo HYP1 : hep_job jo j HYP2 : ~ hep_job jo j
scheduled_at sched j t
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo HYP1 : hep_job jo j HYP2 : ~ hep_job jo j
scheduled_at sched j t
by exfalso .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo HYP1 : hep_job jo j HYP2 : ~~ (jo != j) == true
scheduled_at sched j t
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo HYP1 : hep_job jo j HYP2 : ~~ (jo != j) == true
scheduled_at sched j t
rewrite Bool.negb_involutive in HYP2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo HYP1 : hep_job jo j HYP2 : (jo == j) == true
scheduled_at sched j t
move : HYP2 => /eqP /eqP HYP2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched jo : Job EqSched_jo : sched t = Some jo HYP1 : hep_job jo j HYP2 : jo = j
scheduled_at sched j t
by subst jo; rewrite scheduled_at_def EqSched_jo.
}
} Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 HYP : sched t = Some j
~ interference j t
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 HYP : sched t = Some j
~ interference j t
apply /negP;
rewrite /interference /ideal_jlfp_rta.interference /is_priority_inversion
/is_interference_from_another_hep_job
HYP negb_or; apply /andP; split .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 HYP : sched t = Some j
~~ ~~ hep_job j j
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 HYP : sched t = Some j
~~ ~~ hep_job j j
by rewrite Bool.negb_involutive; eapply (EDF_is_reflexive 0 ).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 HYP : sched t = Some j
~~ (hep_job j j && (j != j))
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant t : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 NEQ : t1 <= t < t2 HYP : sched t = Some j
~~ (hep_job j j && (j != j))
by rewrite negb_and Bool.negb_involutive; apply /orP; right .
}
Qed .
(** Next, we prove that the interference and interfering workload
functions are consistent with sequential tasks. *)
Lemma instantiated_interference_and_workload_consistent_with_sequential_tasks :
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
interference_and_workload_consistent_with_sequential_tasks
arr_seq sched tsk interference interfering_workload
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
interference_and_workload_consistent_with_sequential_tasks
arr_seq sched tsk interference interfering_workload
unfold EDF in *.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
interference_and_workload_consistent_with_sequential_tasks
arr_seq sched tsk interference interfering_workload
intros j t1 t2 ARR TSK POS BUSY.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2
task_workload_between arr_seq tsk 0 t1 =
task_service_of_jobs_in sched tsk
(arrivals_between arr_seq 0 t1) 0 t1
move : H_sched_valid => [CARR MBR].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
task_workload_between arr_seq tsk 0 t1 =
task_service_of_jobs_in sched tsk
(arrivals_between arr_seq 0 t1) 0 t1
eapply instantiated_busy_interval_equivalent_busy_interval in BUSY; eauto 2 with basic_facts.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
task_workload_between arr_seq tsk 0 t1 =
task_service_of_jobs_in sched tsk
(arrivals_between arr_seq 0 t1) 0 t1
eapply all_jobs_have_completed_equiv_workload_eq_service; eauto 2 with basic_facts.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
forall j : Job,
j \in arrivals_between arr_seq 0 t1 ->
job_of_task tsk j -> completed_by sched j t1
intros s INs TSKs.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job INs : s \in arrivals_between arr_seq 0 t1 TSKs : job_of_task tsk s
completed_by sched s t1
rewrite /arrivals_between in INs.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t
completed_by sched s t1
move : (INs) => NEQ.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs, NEQ : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t
completed_by sched s t1
eapply in_arrivals_implies_arrived_between in NEQ; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t NEQ : arrived_between s 0 t1
completed_by sched s t1
move : NEQ => /andP [_ JAs].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t JAs : job_arrival s < t1
completed_by sched s t1
move : (BUSY) => [[ _ [QT [_ /andP [JAj _]]] _]].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t JAs : job_arrival s < t1 QT : quiet_time arr_seq sched j t1 JAj : t1 <= job_arrival j
completed_by sched s t1
apply QT; try done .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t JAs : job_arrival s < t1 QT : quiet_time arr_seq sched j t1 JAj : t1 <= job_arrival j
arrives_in arr_seq s
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t JAs : job_arrival s < t1 QT : quiet_time arr_seq sched j t1 JAj : t1 <= job_arrival j
arrives_in arr_seq s
eapply in_arrivals_implies_arrived; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t JAs : job_arrival s < t1 QT : quiet_time arr_seq sched j t1 JAj : t1 <= job_arrival j
hep_job s j
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job TSKs : job_of_task tsk s INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t JAs : job_arrival s < t1 QT : quiet_time arr_seq sched j t1 JAj : t1 <= job_arrival j
hep_job s j
unfold edf.EDF, EDF; move : TSKs => /eqP TSKs.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t JAs : job_arrival s < t1 QT : quiet_time arr_seq sched j t1 JAj : t1 <= job_arrival j TSKs : job_task s = tsk
hep_job s j
rewrite /job_deadline /job_deadline_from_task_deadline /hep_job TSK TSKs leq_add2r.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job t1, t2 : instant ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jBUSY : busy_interval arr_seq sched j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched s : Job INs : s \in \cat_(0 <=t<t1)arrivals_at arr_seq t JAs : job_arrival s < t1 QT : quiet_time arr_seq sched j t1 JAj : t1 <= job_arrival j TSKs : job_task s = tsk
job_arrival s <= job_arrival j
by apply leq_trans with t1; [apply ltnW | ].
Qed .
(** 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
intros j ARR TSK POS.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost j
exists t1 t2 : nat,
t1 <= job_arrival j < t2 /\
t2 <= t1 + L /\
definitions.busy_interval sched interference
interfering_workload j t1 t2
move : H_sched_valid => [CARR MBR].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jCARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
exists t1 t2 : nat,
t1 <= job_arrival j < t2 /\
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]]]]; eauto 2 with basic_facts.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jCARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jCARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jCARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched t1, 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,
t1 <= job_arrival j < t2 /\
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jCARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched t1, t2 : nat T1 : t1 <= job_arrival j < t2 T2 : t2 <= t1 + L GGG : busy_interval arr_seq sched j t1 t2
t2 <= t1 + L /\
definitions.busy_interval sched interference
interfering_workload j t1 t2
split ; first by done .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_task j = tsk POS : 0 < job_cost jCARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched t1, 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; eauto 2 with basic_facts.
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_task j = tsk.
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.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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
unfold priority_inversion_is_bounded_by, EDF in *.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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
move : H_sched_valid => [CARR MBR].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
priority_inversion_bound
apply leq_trans with (cumulative_priority_inversion sched j t1 t2).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
t1 <= t1 + Δ
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
t1 <= t1 + Δ
by rewrite /is_priority_inversion leq_addr.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
t1 + Δ <= t2
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
t1 + Δ <= t2
by rewrite ltnW.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
cumulative_priority_inversion sched j t1 t2 <=
priority_inversion_bound
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
cumulative_priority_inversion sched j t1 t2 <=
priority_inversion_bound
apply H_priority_inversion_is_bounded; try done .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
busy_interval_prefix arr_seq sched j t1 t2
eapply instantiated_busy_interval_equivalent_busy_interval in H_busy_interval; eauto 2 with basic_facts.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : forall j : Job,
arrives_in arr_seq j ->
job_task j = tsk ->
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 +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 + Δ)
move : H_sched_valid => [CARR MBR].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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;
eauto 2 with basic_facts.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 rewrite -H_job_of_tsk /jobs.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
quiet_time arr_seq sched j t1
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
quiet_time arr_seq sched j t1
rewrite instantiated_quiet_time_equivalent_quiet_time; eauto 2 with basic_facts.
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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; eauto 2 with basic_facts.
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1 (t1 + Δ)).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1 (t1 + Δ)
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1 (t1 + Δ)
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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_task i == tsk_o) task_cost tsk_o
apply leq_sum_seq; move => jo IN0 /eqP EQ.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1 (t1 + Δ) <=
rbf tsk_o Δ
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1 (t1 + Δ) <=
rbf tsk_o Δ
rewrite leq_mul2l; apply /orP; right .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1 (t1 + Δ) <=
max_arrivals tsk_o Δ
rewrite -{2 }[Δ](addKn t1).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 rewrite -H_job_of_tsk -TSKo.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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)
by rewrite /job_deadline /job_deadline_from_task_deadline H_job_of_tsk leq_addr.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o))).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1
(t1 + (A + ε + D tsk - D tsk_o))
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 tsk_o t1
(t1 + (A + ε + D tsk - D tsk_o))
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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_task
i ==
tsk_o)
task_cost tsk_o * 1
rewrite muln1.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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_task
i ==
tsk_o)
task_cost tsk_o
apply leq_sum_seq; move => j0 IN0 /eqP EQ.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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) Δ)
case : (leqP Δ (A + ε + D tsk - D tsko)) => NEQ.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Δ
try (move : (NEQ); move => /minn_idPr ->). (* legacy: needed for mathcomp 1.10 & Coq 8.11 *) Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Δ
now apply workload_le_rbf. } Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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)
apply ltnW in NEQ.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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)
try (move : (NEQ); move => /minn_idPl ->). (* legacy: needed for mathcomp 1.10 & Coq 8.11 *) Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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 <= ?n
eapply total_workload_shorten_range; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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_task j = tsk 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)
now eapply workload_le_rbf'; eauto 2 . }
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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]))
intros j R2 t1 t2 ARR TSK N NCOMPL BUSY.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk 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 : H_sched_valid => [CARR MBR].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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);
eauto 2 with basic_facts; last first .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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
by apply cumulative_priority_inversion_is_bounded with t2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_task j = tsk N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched interference
interfering_workload j t1 t2 CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 => [INSP | [/andP [POSA LTL] [x [LTx INSP2]]]].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 INSP : A = 0
is_in_search_space A
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 INSP : A = 0
is_in_search_space A
subst A.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
0
is_in_search_space 0
apply /andP; split ; [by done | apply /orP; left ].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
0
task_rbf_changes_at 0
rewrite /task_rbf_changes_at neq_ltn; apply /orP; left .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
0
task_rbf 0 < task_rbf (0 + ε)
rewrite /task_rbf /rbf; erewrite task_rbf_0_zero; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
0
0 < task_request_bound_function tsk (0 + ε)
rewrite add0n /task_rbf; apply leq_trans with (task_cost tsk).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
0
0 < task_cost tsk
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
0
0 < task_cost tsk
by eapply leq_trans; eauto 2 ; move : H_job_of_tsk => /eqP <-; apply H_valid_job_cost.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
0
task_cost tsk <= task_request_bound_function tsk ε
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
0
task_cost tsk <= task_request_bound_function tsk ε
by eapply task_rbf_1_ge_task_cost; eauto 2 ; apply /eqP.
} Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
is_in_search_space A
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
is_in_search_space A
apply /andP; split ; first by done .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
task_rbf_changes_at A
|| bound_on_total_hep_workload_changes_at A
rewrite -[_ || _ ]Bool.negb_involutive negb_or; apply /negP; move => /andP [/negPn/eqP EQ1 /hasPn EQ2].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 EQ1 : task_rbf A = task_rbf (A + ε) EQ2 : {in ts,
forall x : Task,
~~
((tsk != x) &&
(rbf x (A + D tsk - D x)
!= rbf x (A + ε + D tsk - D x)))}
False
unfold total_interference_bound in * ;apply INSP2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) EQ2 : {in ts,
forall x : Task,
~~
((tsk != x) &&
(rbf x (A + D tsk - D x)
!= rbf x (A + ε + D tsk - D x)))}
task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x =
task_rbf (A + ε) - task_cost tsk + IBF_other A x
rewrite subn1 addn1 prednK // -EQ1.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) EQ2 : {in ts,
forall x : Task,
~~
((tsk != x) &&
(rbf x (A + D tsk - D x)
!= rbf x (A + ε + D tsk - D x)))}
task_rbf A - task_cost tsk + IBF_other A.-1 x =
task_rbf A - task_cost tsk + IBF_other A x
apply /eqP; rewrite eqn_add2l eqn_add2l.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) EQ2 : {in ts,
forall x : Task,
~~
((tsk != x) &&
(rbf x (A + D tsk - D x)
!= rbf x (A + ε + D tsk - D x)))}
bound_on_total_hep_workload A.-1 x ==
bound_on_total_hep_workload A x
apply : eq_sum_seq; intros tsk_o IN NEQ.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) EQ2 : {in ts,
forall x : Task,
~~
((tsk != x) &&
(rbf x (A + D tsk - D x)
!= rbf x (A + ε + D tsk - D x)))} tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk
rbf tsk_o (minn (A.-1 + ε + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
rewrite addn1 prednK //.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) EQ2 : {in ts,
forall x : Task,
~~
((tsk != x) &&
(rbf x (A + D tsk - D x)
!= rbf x (A + ε + D tsk - D x)))} tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
move : (EQ2 tsk_o IN); clear EQ2;
rewrite eq_sym NEQ Bool.andb_true_l Bool.negb_involutive; move => /eqP EQ2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o)
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
edestruct (leqP (A + ε + D tsk - D tsk_o) x) as [CASE|CASE].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : A + ε + D tsk - D tsk_o <= x
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (A + ε + D tsk - D tsk_o)
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : A + ε + D tsk - D tsk_o <= x
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (A + ε + D tsk - D tsk_o)
have ->: minn (A + D tsk - D tsk_o) x = A + D tsk - D tsk_o.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : A + ε + D tsk - D tsk_o <= x
minn (A + D tsk - D tsk_o) x = A + D tsk - D tsk_o
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : A + ε + D tsk - D tsk_o <= x
minn (A + D tsk - D tsk_o) x = A + D tsk - D tsk_o
rewrite minnE.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : A + ε + D tsk - D tsk_o <= x
A + D tsk - D tsk_o - (A + D tsk - D tsk_o - x) =
A + D tsk - D tsk_o
have CASE2: A + D tsk - D tsk_o <= x
by apply leq_trans with (A + ε + D tsk - D tsk_o);
first (apply leq_sub2r; rewrite leq_add2r leq_addr).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : A + ε + D tsk - D tsk_o <= x CASE2 : A + D tsk - D tsk_o <= x
A + D tsk - D tsk_o - (A + D tsk - D tsk_o - x) =
A + D tsk - D tsk_o
now move : CASE2; rewrite -subn_eq0; move => /eqP CASE2; rewrite CASE2 subn0.
} Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : A + ε + D tsk - D tsk_o <= x
rbf tsk_o (A + D tsk - D tsk_o) ==
rbf tsk_o (A + ε + D tsk - D tsk_o)
try (move : (CASE); move => /minn_idPl ->). (* legacy: needed for mathcomp 1.10 & Coq 8.11 *) Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : A + ε + D tsk - D tsk_o <= x
rbf tsk_o (A + D tsk - D tsk_o) ==
rbf tsk_o (A + ε + D tsk - D tsk_o)
now apply /eqP.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o x
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o x
have ->: minn (A + D tsk - D tsk_o) x = x.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
minn (A + D tsk - D tsk_o) x = x
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
minn (A + D tsk - D tsk_o) x = x
rewrite minnE; rewrite subKn //; rewrite -(leq_add2r 1 ) !addn1 -subSn.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
x < (A + D tsk).+1 - D tsk_o
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
x < (A + D tsk).+1 - D tsk_o
now rewrite -[in X in _ <= X]addn1 -addnA [_ + 1 ]addnC addnA.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
D tsk_o <= A + D tsk
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
D tsk_o <= A + D tsk
enough (POS: 0 < A + ε + D tsk - D tsk_o); last eapply leq_ltn_trans with x; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o POS : 0 < A + ε + D tsk - D tsk_o
D tsk_o <= A + D tsk
now rewrite subn_gt0 -addnA [1 + _]addnC addnA addn1 ltnS in POS.
} Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
rbf tsk_o x == rbf tsk_o x
try (apply ltnW in CASE; move : CASE; move => /minn_idPl; rewrite minnC => ->). (* legacy: needed for mathcomp 1.10 & Coq 8.11 *) Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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
(fun (tsk : Task)
(A
Δ : duration)
=>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ) A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : task_rbf (A - ε + ε) - task_cost tsk +
IBF_other (A - ε) x <>
task_rbf (A + ε) - task_cost tsk +
IBF_other A x EQ1 : task_rbf A = task_rbf (A + ε) tsk_o : Task IN : tsk_o \in ts NEQ : tsk_o != tsk EQ2 : rbf tsk_o (A + D tsk - D tsk_o) =
rbf tsk_o (A + ε + D tsk - D tsk_o) CASE : x < A + ε + D tsk - D tsk_o
rbf tsk_o x == rbf tsk_o x
now apply /eqP.
}
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 +
(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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 +
(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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 +
(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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
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 +
(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 +
(task_rbf (A + ε) - (task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A (A + F)
by rewrite addnA [_ + priority_inversion_bound]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 :
response_time_bounded_by tsk R.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
response_time_bounded_by tsk R
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat
response_time_bounded_by tsk R
intros js ARRs TSKs.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk
job_response_time_bound sched js R
move : H_sched_valid => [CARR MBR].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched
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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched ZERO : job_cost js = 0
job_response_time_bound sched js R
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched POS : 0 < job_cost js
job_response_time_bound sched js R
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); eauto 2 with basic_facts.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched POS : 0 < job_cost js
definitions.work_conserving arr_seq sched tsk
interference interfering_workload
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched POS : 0 < job_cost js
definitions.work_conserving arr_seq sched tsk
interference interfering_workload
by apply instantiated_i_and_w_are_coherent_with_schedule.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 Job : JobType H2 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H3 : 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 (processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : Task ->
(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 H4 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat response_time_bounded_by := task_response_time_bound
arr_seq sched : Task -> duration -> Prop number_of_task_arrivals := arrivals.number_of_task_arrivals
arr_seq : Task ->
instant -> instant -> nat priority_inversion_bound : duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound +
(task_rbf (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 +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_task js = tsk CARR : jobs_come_from_arrival_sequence sched arr_seq MBR : jobs_must_be_ready_to_execute sched 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 ; apply /eqP.
Qed .
End AbstractRTAforEDFwithArrivalCurves .