Library prosa.results.edf.rta.bounded_pi
(* ----------------------------------[ coqtop ]---------------------------------
Welcome to Coq 8.11.2 (June 2020)
----------------------------------------------------------------------------- *)
Require Export prosa.analysis.facts.edf.
Require Export prosa.model.schedule.priority_driven.
Require Export prosa.analysis.facts.busy_interval.carry_in.
Require Export prosa.analysis.definitions.schedulability.
Require Import prosa.model.priority.edf.
Require Import prosa.model.task.absolute_deadline.
Require Import prosa.analysis.abstract.ideal_jlfp_rta.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
Throughout this file, we assume ideal uni-processor schedules.
Throughout this file, we assume the basic (i.e., Liu & Layland) readiness model.
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.
Consider any type of tasks ...
Context {Task : TaskType}.
Context `{TaskCost Task}.
Context `{TaskDeadline Task}.
Context `{TaskRunToCompletionThreshold Task}.
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 `{JobArrival Job}.
Context `{JobCost Job}.
Context `{JobPreemptable Job}.
Context `{JobTask Job Task}.
Context `{JobArrival Job}.
Context `{JobCost Job}.
Context `{JobPreemptable Job}.
For clarity, let's denote the relative deadline of a task as D.
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.
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.
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 ideal uniprocessor schedule of this arrival sequence ...
Variable sched : schedule (ideal.processor_state Job).
Hypothesis H_jobs_come_from_arrival_sequence:
jobs_come_from_arrival_sequence sched arr_seq.
Hypothesis H_jobs_come_from_arrival_sequence:
jobs_come_from_arrival_sequence sched arr_seq.
... where jobs do not execute before their arrival or after completion.
Hypothesis H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched.
Hypothesis H_completed_jobs_dont_execute : completed_jobs_dont_execute sched.
Hypothesis H_completed_jobs_dont_execute : completed_jobs_dont_execute sched.
Note that we differentiate between abstract and
classical notions of work conserving schedule.
Let work_conserving_ab := definitions.work_conserving arr_seq sched.
Let work_conserving_cl := work_conserving.work_conserving arr_seq sched.
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.
Assume we have sequential tasks, i.e, jobs from the
same task execute in the order of their arrival.
Assume that a job cost cannot be larger than a task cost.
Consider an arbitrary task set ts.
Next, we assume that all jobs come from the task set.
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.
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.
Consider a valid preemption model...
...and a valid task run-to-completion threshold function. That is,
[task_run_to_completion_threshold tsk] is (1) no bigger than [tsk]'s
cost, (2) for any job of task [tsk] job_run_to_completion_threshold
is bounded by task_run_to_completion_threshold.
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.
Next, we introduce [task_rbf] as an abbreviation
of the task request bound function of task [tsk].
Using the sum of individual request bound functions, we define the request bound
function of all tasks (total request bound function).
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.
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.
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.
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) Δ).
\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 + ε)]...
...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.
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).
(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 [F + (task cost - task lock-in service) <= R].
Variable R : duration.
Hypothesis H_R_is_maximum:
∀ (A : duration),
is_in_search_space A →
∃ (F : duration),
A + F = priority_inversion_bound
+ (task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk))
+ bound_on_total_hep_workload A (A + F) ∧
F + (task_cost tsk - task_run_to_completion_threshold tsk) ≤ R.
Hypothesis H_R_is_maximum:
∀ (A : duration),
is_in_search_space A →
∃ (F : duration),
A + F = priority_inversion_bound
+ (task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk))
+ bound_on_total_hep_workload A (A + F) ∧
F + (task_cost tsk - task_run_to_completion_threshold tsk) ≤ R.
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.
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.
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.
ideal_jlfp_rta.interfering_workload arr_seq sched j t.
Finally, we define the interference bound function as the sum of the priority
interference bound and the higher-or-equal-priority workload.
Filling Out Hypothesis Of Abstract RTA Theorem
In this section we prove that all hypotheses necessary to use the abstract theorem are satisfied.
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2519)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
unfold EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2521)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 ].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2582)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
============================
~~ interference j t -> scheduled_at sched j t
subgoal 2 (ID 2690) is:
~ interference j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2582)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
============================
~~ interference j t -> scheduled_at sched j t
----------------------------------------------------------------------------- *)
rewrite negb_or /is_priority_inversion /is_priority_inversion
/is_interference_from_another_hep_job.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2703)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
============================
~~ 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].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2743)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2791)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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
subgoal 2 (ID 2837) is:
scheduled_at sched j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2791)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2840)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
Idle : is_idle sched t
EqIdle : sched t = None
============================
False
----------------------------------------------------------------------------- *)
eapply instantiated_busy_interval_equivalent_edf_busy_interval in BUSY; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2850)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
NEQ : t1 <= t < t2
Idle : is_idle sched t
EqIdle : sched t = None
============================
False
----------------------------------------------------------------------------- *)
move: BUSY ⇒ [PREF _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2880)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
NEQ : t1 <= t < t2
Idle : is_idle sched t
EqIdle : sched t = None
PREF : busy_interval.busy_interval_prefix arr_seq sched j t1 t2
============================
False
----------------------------------------------------------------------------- *)
by eapply not_quiet_implies_not_idle; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2837)
subgoal 1 (ID 2837) is:
scheduled_at sched j t
subgoal 2 (ID 2690) is:
~ interference j t
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2837)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2837)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2956)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3027)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3031)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3038)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3163)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
jo : Job
EqSched_jo : sched t = Some jo
HYP1 : hep_job jo j
HYP2 : ~ hep_job jo j
============================
scheduled_at sched j t
subgoal 2 (ID 3164) is:
scheduled_at sched j t
----------------------------------------------------------------------------- *)
- by exfalso.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3164)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3261)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3323)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2690)
subgoal 1 (ID 2690) is:
~ interference j t
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2690)
subgoal 1 (ID 2690) is:
~ interference j t
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2690)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
HYP : sched t = Some j
============================
~ interference j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2690)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3424)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
HYP : sched t = Some j
============================
~~ ~~ hep_job j j
subgoal 2 (ID 3425) is:
~~ (hep_job j j && (j != j))
----------------------------------------------------------------------------- *)
- by rewrite Bool.negb_involutive; eapply (EDF_is_reflexive 0).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3425)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
work_conserving_ab tsk interference interfering_workload.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2519)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
unfold EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2521)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 ].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2582)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
============================
~~ interference j t -> scheduled_at sched j t
subgoal 2 (ID 2690) is:
~ interference j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2582)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
============================
~~ interference j t -> scheduled_at sched j t
----------------------------------------------------------------------------- *)
rewrite negb_or /is_priority_inversion /is_priority_inversion
/is_interference_from_another_hep_job.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2703)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
============================
~~ 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].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2743)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2791)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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
subgoal 2 (ID 2837) is:
scheduled_at sched j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2791)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2840)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
Idle : is_idle sched t
EqIdle : sched t = None
============================
False
----------------------------------------------------------------------------- *)
eapply instantiated_busy_interval_equivalent_edf_busy_interval in BUSY; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2850)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
NEQ : t1 <= t < t2
Idle : is_idle sched t
EqIdle : sched t = None
============================
False
----------------------------------------------------------------------------- *)
move: BUSY ⇒ [PREF _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2880)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
NEQ : t1 <= t < t2
Idle : is_idle sched t
EqIdle : sched t = None
PREF : busy_interval.busy_interval_prefix arr_seq sched j t1 t2
============================
False
----------------------------------------------------------------------------- *)
by eapply not_quiet_implies_not_idle; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2837)
subgoal 1 (ID 2837) is:
scheduled_at sched j t
subgoal 2 (ID 2690) is:
~ interference j t
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2837)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2837)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2956)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3027)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3031)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3038)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3163)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
jo : Job
EqSched_jo : sched t = Some jo
HYP1 : hep_job jo j
HYP2 : ~ hep_job jo j
============================
scheduled_at sched j t
subgoal 2 (ID 3164) is:
scheduled_at sched j t
----------------------------------------------------------------------------- *)
- by exfalso.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3164)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3261)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3323)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2690)
subgoal 1 (ID 2690) is:
~ interference j t
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2690)
subgoal 1 (ID 2690) is:
~ interference j t
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2690)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
HYP : sched t = Some j
============================
~ interference j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2690)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3424)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval sched interference interfering_workload j t1 t2
NEQ : t1 <= t < t2
HYP : sched t = Some j
============================
~~ ~~ hep_job j j
subgoal 2 (ID 3425) is:
~~ (hep_job j j && (j != j))
----------------------------------------------------------------------------- *)
- by rewrite Bool.negb_involutive; eapply (EDF_is_reflexive 0).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3425)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2525)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
unfold EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2527)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2535)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : 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
----------------------------------------------------------------------------- *)
eapply instantiated_busy_interval_equivalent_edf_busy_interval in BUSY; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2545)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched 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
----------------------------------------------------------------------------- *)
eapply all_jobs_have_completed_equiv_workload_eq_service; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2595)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
============================
forall j0 : Job,
j0 \in arrivals_between arr_seq 0 t1 ->
job_of_task tsk j0 -> completed_by sched j0 t1
----------------------------------------------------------------------------- *)
intros s INs TSKs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2643)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2711)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
move: (INs) ⇒ NEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2713)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs, NEQ : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
eapply in_arrivals_implies_arrived_between in NEQ; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2716)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
NEQ : arrived_between s 0 t1
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
move: NEQ ⇒ /andP [_ JAs].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2775)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
move: (BUSY) ⇒ [[ _ [QT [_ /andP [JAj _]]] _]].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2856)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.quiet_time arr_seq sched j t1
JAj : t1 <= job_arrival j
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
apply QT; try done.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2857)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.quiet_time arr_seq sched j t1
JAj : t1 <= job_arrival j
============================
arrives_in arr_seq s
subgoal 2 (ID 2858) is:
hep_job s j
----------------------------------------------------------------------------- *)
- eapply in_arrivals_implies_arrived; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2858)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.quiet_time arr_seq sched j t1
JAj : t1 <= job_arrival j
============================
hep_job s j
----------------------------------------------------------------------------- *)
- unfold edf.EDF, EDF; move: TSKs ⇒ /eqP TSKs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2952)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2972)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.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 | ].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
interference_and_workload_consistent_with_sequential_tasks
arr_seq sched tsk interference interfering_workload.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2525)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
unfold EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2527)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2535)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : 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
----------------------------------------------------------------------------- *)
eapply instantiated_busy_interval_equivalent_edf_busy_interval in BUSY; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2545)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched 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
----------------------------------------------------------------------------- *)
eapply all_jobs_have_completed_equiv_workload_eq_service; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2595)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
============================
forall j0 : Job,
j0 \in arrivals_between arr_seq 0 t1 ->
job_of_task tsk j0 -> completed_by sched j0 t1
----------------------------------------------------------------------------- *)
intros s INs TSKs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2643)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2711)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
move: (INs) ⇒ NEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2713)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs, NEQ : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
eapply in_arrivals_implies_arrived_between in NEQ; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2716)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
NEQ : arrived_between s 0 t1
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
move: NEQ ⇒ /andP [_ JAs].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2775)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
move: (BUSY) ⇒ [[ _ [QT [_ /andP [JAj _]]] _]].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2856)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.quiet_time arr_seq sched j t1
JAj : t1 <= job_arrival j
============================
completed_by sched s t1
----------------------------------------------------------------------------- *)
apply QT; try done.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2857)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.quiet_time arr_seq sched j t1
JAj : t1 <= job_arrival j
============================
arrives_in arr_seq s
subgoal 2 (ID 2858) is:
hep_job s j
----------------------------------------------------------------------------- *)
- eapply in_arrivals_implies_arrived; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2858)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
TSKs : job_of_task tsk s
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.quiet_time arr_seq sched j t1
JAj : t1 <= job_arrival j
============================
hep_job s j
----------------------------------------------------------------------------- *)
- unfold edf.EDF, EDF; move: TSKs ⇒ /eqP TSKs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2952)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2972)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 j
BUSY : busy_interval.busy_interval arr_seq sched j t1 t2
s : Job
INs : s \in \cat_(0<=t<t1|true)arrivals_at arr_seq t
JAs : job_arrival s < t1
QT : busy_interval.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 | ].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2533)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
unfold EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2535)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2540)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 /\
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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2570)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
============================
forall t : instant,
workload_of_jobs predT (arrivals_between arr_seq t (t + L)) <= L
subgoal 2 (ID 2591) is:
exists t0 t3 : nat,
t0 <= job_arrival j < t3 /\
t3 <= t0 + L /\
busy_interval sched interference interfering_workload j t0 t3
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2570)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
============================
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''.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2591)
subgoal 1 (ID 2591) is:
exists t0 t3 : nat,
t0 <= job_arrival j < t3 /\
t3 <= t0 + L /\
busy_interval sched interference interfering_workload j t0 t3
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2591)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
t1, t2 : nat
T1 : t1 <= job_arrival j < t2
T2 : t2 <= t1 + L
GGG : busy_interval.busy_interval arr_seq sched j t1 t2
============================
exists t0 t3 : nat,
t0 <= job_arrival j < t3 /\
t3 <= t0 + L /\
busy_interval sched interference interfering_workload j t0 t3
----------------------------------------------------------------------------- *)
∃ t1, t2; split; first by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2648)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
t1, t2 : nat
T1 : t1 <= job_arrival j < t2
T2 : t2 <= t1 + L
GGG : busy_interval.busy_interval arr_seq sched j t1 t2
============================
t2 <= t1 + L /\
busy_interval sched interference interfering_workload j t1 t2
----------------------------------------------------------------------------- *)
split; first by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2651)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
t1, t2 : nat
T1 : t1 <= job_arrival j < t2
T2 : t2 <= t1 + L
GGG : busy_interval.busy_interval arr_seq sched j t1 t2
============================
busy_interval sched interference interfering_workload j t1 t2
----------------------------------------------------------------------------- *)
by eapply instantiated_busy_interval_equivalent_edf_busy_interval; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
busy_intervals_are_bounded_by arr_seq sched tsk interference interfering_workload L.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2533)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
unfold EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2535)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2540)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 /\
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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2570)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
============================
forall t : instant,
workload_of_jobs predT (arrivals_between arr_seq t (t + L)) <= L
subgoal 2 (ID 2591) is:
exists t0 t3 : nat,
t0 <= job_arrival j < t3 /\
t3 <= t0 + L /\
busy_interval sched interference interfering_workload j t0 t3
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2570)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
============================
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''.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2591)
subgoal 1 (ID 2591) is:
exists t0 t3 : nat,
t0 <= job_arrival j < t3 /\
t3 <= t0 + L /\
busy_interval sched interference interfering_workload j t0 t3
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2591)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
t1, t2 : nat
T1 : t1 <= job_arrival j < t2
T2 : t2 <= t1 + L
GGG : busy_interval.busy_interval arr_seq sched j t1 t2
============================
exists t0 t3 : nat,
t0 <= job_arrival j < t3 /\
t3 <= t0 + L /\
busy_interval sched interference interfering_workload j t0 t3
----------------------------------------------------------------------------- *)
∃ t1, t2; split; first by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2648)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
t1, t2 : nat
T1 : t1 <= job_arrival j < t2
T2 : t2 <= t1 + L
GGG : busy_interval.busy_interval arr_seq sched j t1 t2
============================
t2 <= t1 + L /\
busy_interval sched interference interfering_workload j t1 t2
----------------------------------------------------------------------------- *)
split; first by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2651)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
t1, t2 : nat
T1 : t1 <= job_arrival j < t2
T2 : t2 <= t1 + L
GGG : busy_interval.busy_interval arr_seq sched j t1 t2
============================
busy_interval sched interference interfering_workload j t1 t2
----------------------------------------------------------------------------- *)
by eapply instantiated_busy_interval_equivalent_edf_busy_interval; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
Next, we prove that IBF is indeed an interference bound.
We show that task_interference_is_bounded_by is bounded by IBF 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 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.
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).
Consider an arbitrary shift Δ inside the busy interval ...
... and the set of all arrivals between [t1] and [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].
Predicate [EDF_not_from tsk] holds true for any job [jo]
such that [job_deadline jo <= job_deadline j] and [job_task jo ≠ tsk].
Recall that [IBF(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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2565)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold priority_inversion_is_bounded_by, EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2567)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : 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
----------------------------------------------------------------------------- *)
apply leq_trans with (cumulative_priority_inversion sched j t1 t2).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2575)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
cumulative_priority_inversion sched j t1 t2
subgoal 2 (ID 2576) is:
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
- rewrite [X in _ ≤ X](@big_cat_nat _ _ _ (t1 + Δ)) //=.
(* ----------------------------------[ coqtop ]---------------------------------
4 subgoals (ID 2604)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
\sum_(t1 <= i < t1 + Δ) is_priority_inversion sched j i +
\sum_(t1 + Δ <= i < t2) is_priority_inversion sched j i
subgoal 2 (ID 2627) is:
t1 <= t1 + Δ
subgoal 3 (ID 2650) is:
t1 + Δ <= t2
subgoal 4 (ID 2576) is:
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
+ by rewrite leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2627)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
t1 <= t1 + Δ
subgoal 2 (ID 2650) is:
t1 + Δ <= t2
subgoal 3 (ID 2576) is:
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
+ by rewrite /is_priority_inversion leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2650)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
t1 + Δ <= t2
subgoal 2 (ID 2576) is:
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
+ by rewrite ltnW.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2576)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
- apply H_priority_inversion_is_bounded; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2693)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
busy_interval.busy_interval_prefix arr_seq sched j t1 t2
----------------------------------------------------------------------------- *)
eapply instantiated_busy_interval_equivalent_edf_busy_interval in H_busy_interval; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2886)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.busy_interval arr_seq sched j t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
busy_interval.busy_interval_prefix arr_seq sched j t1 t2
----------------------------------------------------------------------------- *)
by move: H_busy_interval ⇒ [PREF _].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
cumulative_priority_inversion sched j t1 (t1 + Δ) ≤ priority_inversion_bound.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2565)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold priority_inversion_is_bounded_by, EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2567)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : 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
----------------------------------------------------------------------------- *)
apply leq_trans with (cumulative_priority_inversion sched j t1 t2).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2575)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
cumulative_priority_inversion sched j t1 t2
subgoal 2 (ID 2576) is:
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
- rewrite [X in _ ≤ X](@big_cat_nat _ _ _ (t1 + Δ)) //=.
(* ----------------------------------[ coqtop ]---------------------------------
4 subgoals (ID 2604)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
\sum_(t1 <= i < t1 + Δ) is_priority_inversion sched j i +
\sum_(t1 + Δ <= i < t2) is_priority_inversion sched j i
subgoal 2 (ID 2627) is:
t1 <= t1 + Δ
subgoal 3 (ID 2650) is:
t1 + Δ <= t2
subgoal 4 (ID 2576) is:
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
+ by rewrite leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2627)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
t1 <= t1 + Δ
subgoal 2 (ID 2650) is:
t1 + Δ <= t2
subgoal 3 (ID 2576) is:
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
+ by rewrite /is_priority_inversion leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2650)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
t1 + Δ <= t2
subgoal 2 (ID 2576) is:
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
+ by rewrite ltnW.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2576)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
cumulative_priority_inversion sched j t1 t2 <= priority_inversion_bound
----------------------------------------------------------------------------- *)
- apply H_priority_inversion_is_bounded; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2693)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
busy_interval.busy_interval_prefix arr_seq sched j t1 t2
----------------------------------------------------------------------------- *)
eapply instantiated_busy_interval_equivalent_edf_busy_interval in H_busy_interval; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2886)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
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_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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.busy_interval arr_seq sched j t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job
EDF_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo == tsk) :
Task -> Job -> bool
EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk)
: Task -> Job -> bool
============================
busy_interval.busy_interval_prefix arr_seq sched j t1 t2
----------------------------------------------------------------------------- *)
by move: H_busy_interval ⇒ [PREF _].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
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 + Δ).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2578)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2649)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)
----------------------------------------------------------------------------- *)
erewrite instantiated_cumulative_interference_of_hep_tasks_equal_total_interference_of_hep_tasks;
eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2656)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
service_of_jobs sched
(fun jhp : Job => hep_job jhp j && (job_task jhp != job_task j))
(arrivals_between arr_seq t1 (t1 + Δ)) t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)
subgoal 2 (ID 2662) is:
busy_interval.quiet_time arr_seq sched j t1
----------------------------------------------------------------------------- *)
- by rewrite -H_job_of_tsk /jobs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2662)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
busy_interval.quiet_time arr_seq sched j t1
----------------------------------------------------------------------------- *)
- rewrite /edf.EDF /EDF instantiated_quiet_time_equivalent_quiet_time //.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2770)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
reflexive_priorities
subgoal 2 (ID 2771) is:
policy_respects_sequential_tasks
----------------------------------------------------------------------------- *)
+ by apply EDF_is_reflexive.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2771)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
policy_respects_sequential_tasks
----------------------------------------------------------------------------- *)
+ by apply EDF_respects_sequential_tasks.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + Δ)
≤ service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2578)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2649)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)
----------------------------------------------------------------------------- *)
erewrite instantiated_cumulative_interference_of_hep_tasks_equal_total_interference_of_hep_tasks;
eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2656)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
service_of_jobs sched
(fun jhp : Job => hep_job jhp j && (job_task jhp != job_task j))
(arrivals_between arr_seq t1 (t1 + Δ)) t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)
subgoal 2 (ID 2662) is:
busy_interval.quiet_time arr_seq sched j t1
----------------------------------------------------------------------------- *)
- by rewrite -H_job_of_tsk /jobs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2662)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
busy_interval.quiet_time arr_seq sched j t1
----------------------------------------------------------------------------- *)
- rewrite /edf.EDF /EDF instantiated_quiet_time_equivalent_quiet_time //.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2770)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
reflexive_priorities
subgoal 2 (ID 2771) is:
policy_respects_sequential_tasks
----------------------------------------------------------------------------- *)
+ by apply EDF_is_reflexive.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2771)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : quiet_time sched interference interfering_workload j t1
============================
policy_respects_sequential_tasks
----------------------------------------------------------------------------- *)
+ by apply EDF_respects_sequential_tasks.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2584)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
by apply service_of_jobs_le_workload; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)
≤ workload_of_jobs (EDF_not_from tsk) jobs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2584)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
by apply service_of_jobs_le_workload; eauto 2 with basic_facts.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
Next, we reorder summation. So the total workload of jobs
with higher-or-equal priority from other tasks is equal to
the sum over all tasks [tsk_o] that are to equal to task
[tsk] of workload of jobs with higher-or-equal priority
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2595)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold EDF_from.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2597)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2668)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
rewrite (exchange_big_dep (EDF_not_from tsk)) //=.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2692)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
- rewrite /workload_of_jobs big_seq_cond [X in _ ≤ X]big_seq_cond.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2773)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
apply leq_sum; move ⇒ jo /andP [ARRo /andP [HEQ TSKo]].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2853)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
rewrite (big_rem (job_task jo)) //=.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2876)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2899) is:
job_task jo \in ts
subgoal 3 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
rewrite /EDF_from HEQ eq_refl TSKo andTb andTb leq_addr //.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2899)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
- eapply H_all_jobs_from_taskset, in_arrivals_implies_arrived; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2715)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3050)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3078)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3085)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
workload_of_jobs (EDF_not_from tsk) jobs
≤ \sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2595)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold EDF_from.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2597)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2668)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
rewrite (exchange_big_dep (EDF_not_from tsk)) //=.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2692)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
- rewrite /workload_of_jobs big_seq_cond [X in _ ≤ X]big_seq_cond.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2773)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
apply leq_sum; move ⇒ jo /andP [ARRo /andP [HEQ TSKo]].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2853)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
rewrite (big_rem (job_task jo)) //=.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2876)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2899) is:
job_task jo \in ts
subgoal 3 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
rewrite /EDF_from HEQ eq_refl TSKo andTb andTb leq_addr //.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2899)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2715) is:
forall (i : Task) (j0 : Job),
i != tsk -> EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
----------------------------------------------------------------------------- *)
- eapply H_all_jobs_from_taskset, in_arrivals_implies_arrived; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2715)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3050)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3078)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3085)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
Next we focus on one task [tsk_o ≠ tsk] and consider two cases.
Case 1: [Δ ≤ A + ε + D tsk - D tsk_o].
Consider an arbitrary task [tsk_o ≠ tsk] from [ts].
And assume that [Δ ≤ 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 Δ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2603)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold workload_of_jobs, EDF_from.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2605)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 + Δ)).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2608)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 + Δ)
subgoal 2 (ID 2609) is:
task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2608)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2622)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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
subgoal 2 (ID 2623) is:
\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 + Δ)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2622)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2678)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2623)
subgoal 1 (ID 2623) is:
\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 + Δ)
subgoal 2 (ID 2609) is:
task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2623)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 + Δ)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2623)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2755)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2792)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
subgoal 1 (ID 2609) is:
task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
subgoal 1 (ID 2609) is:
task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 Δ
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2829)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2835)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case1.
workload_of_jobs (EDF_from tsk_o) jobs ≤ rbf tsk_o Δ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2603)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold workload_of_jobs, EDF_from.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2605)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 + Δ)).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2608)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 + Δ)
subgoal 2 (ID 2609) is:
task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2608)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2622)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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
subgoal 2 (ID 2623) is:
\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 + Δ)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2622)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2678)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2623)
subgoal 1 (ID 2623) is:
\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 + Δ)
subgoal 2 (ID 2609) is:
task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2623)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 + Δ)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2623)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2755)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2792)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
subgoal 1 (ID 2609) is:
task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
subgoal 1 (ID 2609) is:
task_cost tsk_o * number_of_task_arrivals tsk_o t1 (t1 + Δ) <= rbf tsk_o Δ
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 Δ
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2829)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2835)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case1.
Case 2: [A + ε + D tsk - D tsk_o ≤ Δ].
Consider an arbitrary task [tsk_o ≠ tsk] from [ts].
And assume that [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))).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2607)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold workload_of_jobs, EDF_from.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2680)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2684)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 //].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2699)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 //=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2721)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2761)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2770)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2799)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2839)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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]].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2951)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2954)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3002)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3025)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
- move: ARRIN; rewrite leqNgt; move ⇒ /negP ARRIN; apply: ARRIN.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3064)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
rewrite -(ltn_add2r (D tsk_o)).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3068)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
apply leq_ltn_trans with (job_arrival j + D tsk); first by rewrite -H_job_of_tsk -TSKo.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3072)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
rewrite addnBA // addnA addnA subnKC // subnK.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 3152)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3153) is:
D tsk_o <= job_arrival j + ε + D tsk
subgoal 3 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
+ by rewrite ltn_add2r addn1.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3153)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
+ apply leq_trans with (A + ε + D tsk); first by done.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3163)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
by rewrite !leq_add2r leq_subr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3026)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3220)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3223)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
+ rewrite subh1 // addnBA.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 3259)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3260) is:
t1 <= job_arrival j + D tsk
subgoal 3 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
rewrite [in X in _ ≤ X]addnC -addnBA.
(* ----------------------------------[ coqtop ]---------------------------------
4 subgoals (ID 3277)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 3278) is:
t1 <= job_arrival jo
subgoal 3 (ID 3260) is:
t1 <= job_arrival j + D tsk
subgoal 4 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
× by rewrite /job_deadline /job_deadline_from_task_deadline H_job_of_tsk leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 3278)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3260) is:
t1 <= job_arrival j + D tsk
subgoal 3 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
× by apply leq_trans with (t1 + (A + ε + D tsk - D tsk_o)); first rewrite leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3260)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
by apply leq_trans with (job_arrival j); [ | by rewrite leq_addr].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3224)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3309)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3310)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3311) is:
A + ε + D tsk < task_deadline (job_task jo)
----------------------------------------------------------------------------- *)
× by rewrite leq_add2r leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3311)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
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))).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2607)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold workload_of_jobs, EDF_from.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2609)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2680)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2684)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 //].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2699)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 //=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2721)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2761)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2770)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2799)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2839)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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]].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2951)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2954)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3002)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3025)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
- move: ARRIN; rewrite leqNgt; move ⇒ /negP ARRIN; apply: ARRIN.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3064)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
rewrite -(ltn_add2r (D tsk_o)).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3068)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
apply leq_ltn_trans with (job_arrival j + D tsk); first by rewrite -H_job_of_tsk -TSKo.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3072)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
rewrite addnBA // addnA addnA subnKC // subnK.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 3152)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3153) is:
D tsk_o <= job_arrival j + ε + D tsk
subgoal 3 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
+ by rewrite ltn_add2r addn1.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3153)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
+ apply leq_trans with (A + ε + D tsk); first by done.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3163)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3026) is:
False
----------------------------------------------------------------------------- *)
by rewrite !leq_add2r leq_subr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3026)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3220)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3223)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
+ rewrite subh1 // addnBA.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 3259)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3260) is:
t1 <= job_arrival j + D tsk
subgoal 3 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
rewrite [in X in _ ≤ X]addnC -addnBA.
(* ----------------------------------[ coqtop ]---------------------------------
4 subgoals (ID 3277)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 3278) is:
t1 <= job_arrival jo
subgoal 3 (ID 3260) is:
t1 <= job_arrival j + D tsk
subgoal 4 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
× by rewrite /job_deadline /job_deadline_from_task_deadline H_job_of_tsk leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 3278)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3260) is:
t1 <= job_arrival j + D tsk
subgoal 3 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
× by apply leq_trans with (t1 + (A + ε + D tsk - D tsk_o)); first rewrite leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3260)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3224) is:
job_arrival jo + (A + D tsk) < job_deadline jo
----------------------------------------------------------------------------- *)
by apply leq_trans with (job_arrival j); [ | by rewrite leq_addr].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3224)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3309)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3310)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 3311) is:
A + ε + D tsk < task_deadline (job_task jo)
----------------------------------------------------------------------------- *)
× by rewrite leq_add2r leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3311)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
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).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2611)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold workload_of_jobs, EDF_from.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2613)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2684)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2688)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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))).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2691)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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))
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
- apply leq_trans with
(\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | job_task jo == tsk_o) job_cost jo).
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2705)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2706) is:
\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))
subgoal 3 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
+ rewrite big_mkcond [X in _ ≤ X]big_mkcond //=.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2730)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 2706) is:
\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))
subgoal 3 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
rewrite leq_sum //; intros s _.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2790)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 2706) is:
\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))
subgoal 3 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
by case (EDF s j).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2706)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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))
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
+ rewrite /number_of_task_arrivals /task.arrivals.number_of_task_arrivals
-sum1_size big_distrr /= big_filter.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2825)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
rewrite muln1.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2830)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
apply leq_sum_seq; move ⇒ j0 IN0 /eqP EQ.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2867)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
rewrite -EQ.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2869)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
apply H_valid_job_cost.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2870)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
by apply in_arrivals_implies_arrived in IN0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2692)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2876)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2880)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2911)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2917)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case2.
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).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2611)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
unfold workload_of_jobs, EDF_from.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2613)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2684)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2688)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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))).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2691)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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))
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
- apply leq_trans with
(\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | job_task jo == tsk_o) job_cost jo).
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2705)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2706) is:
\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))
subgoal 3 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
+ rewrite big_mkcond [X in _ ≤ X]big_mkcond //=.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2730)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 2706) is:
\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))
subgoal 3 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
rewrite leq_sum //; intros s _.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2790)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 2706) is:
\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))
subgoal 3 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
by case (EDF s j).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2706)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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))
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
+ rewrite /number_of_task_arrivals /task.arrivals.number_of_task_arrivals
-sum1_size big_distrr /= big_filter.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2825)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
rewrite muln1.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2830)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
apply leq_sum_seq; move ⇒ j0 IN0 /eqP EQ.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2867)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
rewrite -EQ.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2869)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
apply H_valid_job_cost.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2870)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2692) is:
task_cost tsk_o *
number_of_task_arrivals tsk_o t1 (t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o V
----------------------------------------------------------------------------- *)
by apply in_arrivals_implies_arrived in IN0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2692)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2876)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2880)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2911)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2917)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
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 Δ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2604)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2675)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2679)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2691)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
subgoal 2 (ID 2692) is:
workload_of_jobs (EDF_from tsko) jobs <=
rbf tsko (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2691)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
try (move: (NEQ); move⇒ /minn_idPr ->).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2726)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 Δ
----------------------------------------------------------------------------- *)
(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
now apply workload_le_rbf.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2692)
subgoal 1 (ID 2692) is:
workload_of_jobs (EDF_from tsko) jobs <=
rbf tsko (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2692)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2692)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
apply ltnW in NEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2728)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
try (move: (NEQ); move⇒ /minn_idPl ->).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2763)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
----------------------------------------------------------------------------- *)
(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
eapply leq_trans.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2765)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2766) is:
?n <= rbf tsko (A + ε + D tsk - D tsko)
----------------------------------------------------------------------------- *)
eapply total_workload_shorten_range; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2766)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Inequalities.
\sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs
≤ bound_on_total_hep_workload A Δ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2604)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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.
move: (H_busy_interval) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2675)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2679)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2691)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
subgoal 2 (ID 2692) is:
workload_of_jobs (EDF_from tsko) jobs <=
rbf tsko (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2691)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
try (move: (NEQ); move⇒ /minn_idPr ->).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2726)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 Δ
----------------------------------------------------------------------------- *)
(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
now apply workload_le_rbf.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2692)
subgoal 1 (ID 2692) is:
workload_of_jobs (EDF_from tsko) jobs <=
rbf tsko (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2692)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2692)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
apply ltnW in NEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2728)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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 (minn (A + ε + D tsk - D tsko) Δ)
----------------------------------------------------------------------------- *)
try (move: (NEQ); move⇒ /minn_idPl ->).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2763)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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)
----------------------------------------------------------------------------- *)
(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
eapply leq_trans.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2765)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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
subgoal 2 (ID 2766) is:
?n <= rbf tsko (A + ε + D tsk - D tsko)
----------------------------------------------------------------------------- *)
eapply total_workload_shorten_range; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2766)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 sched interference interfering_workload j
t1 t2
A := job_arrival j - t1 : nat
Δ : duration
H_Δ_in_busy : t1 + Δ < t2
jobs := arrivals_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 : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
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. Therefore, in order for the IBF signature to
match the required signature in module abstract_seq_RTA, we
wrap the IBF 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 A R).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2542)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 A]))
----------------------------------------------------------------------------- *)
Proof.
unfold EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2544)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 A]))
----------------------------------------------------------------------------- *)
intros j R2 t1 t2 ARR TSK N NCOMPL BUSY.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2554)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : 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 offset R2
----------------------------------------------------------------------------- *)
move: (posnP (@job_cost _ H4 j)) ⇒ [ZERO|POS].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2571)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
ZERO : job_cost j = 0
============================
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
IBF offset R2
subgoal 2 (ID 2572) is:
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
- exfalso; move: NCOMPL ⇒ /negP COMPL; apply: COMPL.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2607)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
ZERO : job_cost j = 0
============================
completed_by sched j (t1 + R2)
subgoal 2 (ID 2572) is:
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
by rewrite /completed_by /completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2572)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
============================
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
- move: (BUSY) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2694)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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 offset R2
----------------------------------------------------------------------------- *)
rewrite (cumulative_task_interference_split arr_seq sched _ _ _ tsk j);
eauto 2 with basic_facts; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2733)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
j \in arrivals_before arr_seq t2
subgoal 2 (ID 2727) is:
let offset := job_arrival j - t1 in
cumulative_priority_inversion sched j t1 (t1 + R2) +
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2733)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
j \in arrivals_before arr_seq t2
----------------------------------------------------------------------------- *)
by eapply arrived_between_implies_in_arrivals; eauto.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2727)
subgoal 1 (ID 2727) is:
let offset := job_arrival j - t1 in
cumulative_priority_inversion sched j t1 (t1 + R2) +
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2727)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
let offset := job_arrival j - t1 in
cumulative_priority_inversion sched j t1 (t1 + R2) +
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
rewrite /I leq_add //.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2776)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
cumulative_priority_inversion sched j t1 (t1 + R2) <=
priority_inversion_bound
subgoal 2 (ID 2777) is:
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
+ by apply cumulative_priority_inversion_is_bounded with t2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2777)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2828)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
?n
subgoal 2 (ID 2829) is:
?n <= bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
eapply cumulative_interference_is_bounded_by_total_service; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2829)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2841)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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
subgoal 2 (ID 2842) is:
?n <= bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
eapply total_service_is_bounded_by_total_workload; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2842)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2844)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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
subgoal 2 (ID 2845) is:
?n <= bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
eapply reorder_summation; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2845)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2849)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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
subgoal 2 (ID 2850) is:
?n <= bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
eapply sum_of_workloads_is_at_most_bound_on_total_hep_workload; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2850)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End TaskInterferenceIsBoundedByIBF.
task_interference_is_bounded_by
arr_seq sched tsk interference interfering_workload (fun tsk A R ⇒ IBF A R).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2542)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 A]))
----------------------------------------------------------------------------- *)
Proof.
unfold EDF in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2544)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 A]))
----------------------------------------------------------------------------- *)
intros j R2 t1 t2 ARR TSK N NCOMPL BUSY.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2554)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : 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 offset R2
----------------------------------------------------------------------------- *)
move: (posnP (@job_cost _ H4 j)) ⇒ [ZERO|POS].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2571)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
ZERO : job_cost j = 0
============================
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
IBF offset R2
subgoal 2 (ID 2572) is:
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
- exfalso; move: NCOMPL ⇒ /negP COMPL; apply: COMPL.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2607)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
ZERO : job_cost j = 0
============================
completed_by sched j (t1 + R2)
subgoal 2 (ID 2572) is:
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
by rewrite /completed_by /completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2572)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
============================
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk t2 t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
- move: (BUSY) ⇒ [[/andP [JINBI JINBI2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2694)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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 offset R2
----------------------------------------------------------------------------- *)
rewrite (cumulative_task_interference_split arr_seq sched _ _ _ tsk j);
eauto 2 with basic_facts; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2733)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
j \in arrivals_before arr_seq t2
subgoal 2 (ID 2727) is:
let offset := job_arrival j - t1 in
cumulative_priority_inversion sched j t1 (t1 + R2) +
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2733)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
j \in arrivals_before arr_seq t2
----------------------------------------------------------------------------- *)
by eapply arrived_between_implies_in_arrivals; eauto.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2727)
subgoal 1 (ID 2727) is:
let offset := job_arrival j - t1 in
cumulative_priority_inversion sched j t1 (t1 + R2) +
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2727)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
let offset := job_arrival j - t1 in
cumulative_priority_inversion sched j t1 (t1 + R2) +
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
IBF offset R2
----------------------------------------------------------------------------- *)
rewrite /I leq_add //.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2776)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
cumulative_priority_inversion sched j t1 (t1 + R2) <=
priority_inversion_bound
subgoal 2 (ID 2777) is:
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
+ by apply cumulative_priority_inversion_is_bounded with t2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2777)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2828)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : quiet_time sched interference interfering_workload j t1
============================
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + R2) <=
?n
subgoal 2 (ID 2829) is:
?n <= bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
eapply cumulative_interference_is_bounded_by_total_service; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2829)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2841)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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
subgoal 2 (ID 2842) is:
?n <= bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
eapply total_service_is_bounded_by_total_workload; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2842)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2844)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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
subgoal 2 (ID 2845) is:
?n <= bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
eapply reorder_summation; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2845)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2849)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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
subgoal 2 (ID 2850) is:
?n <= bound_on_total_hep_workload (job_arrival j - t1) R2
----------------------------------------------------------------------------- *)
eapply sum_of_workloads_is_at_most_bound_on_total_hep_workload; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2850)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 : busy_interval sched interference interfering_workload j t1 t2
POS : 0 < job_cost j
JINBI : t1 <= job_arrival j
JINBI2 : job_arrival j < t2
QT : 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.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End TaskInterferenceIsBoundedByIBF.
Finally, we show that there exists a solution for the response-time recurrence.
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.
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(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.
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2545)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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.
move: H_A_is_in_abstract_search_space ⇒ [INSP | [/andP [POSA LTL] [x [LTx INSP2]]]].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2559)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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
subgoal 2 (ID 2629) is:
is_in_search_space A
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2559)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2635)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2688)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2719)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2724)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2761)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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
subgoal 2 (ID 2762) is:
task_cost tsk <= task_request_bound_function tsk ε
----------------------------------------------------------------------------- *)
- by eapply leq_trans; eauto 2;
rewrite -(eqbool_to_eqprop H_job_of_tsk); apply H_valid_job_cost.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2762)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 using eqbool_to_eqprop.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2629)
subgoal 1 (ID 2629) is:
is_in_search_space A
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2629)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 < A
LTL : 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
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2629)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 < A
LTL : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2860)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 < A
LTL : 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].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3014)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 < A
LTL : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3017)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (A - ε) x =
task_rbf (A + ε) - task_cost tsk + IBF A x
----------------------------------------------------------------------------- *)
rewrite subn1 addn1 prednK // -EQ1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3053)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (predn A) x =
task_rbf A - task_cost tsk + IBF A x
----------------------------------------------------------------------------- *)
apply/eqP; rewrite eqn_add2l eqn_add2l.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3118)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (predn A) x == bound_on_total_hep_workload A x
----------------------------------------------------------------------------- *)
apply: eq_sum_seq; intros tsk_o IN NEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3149)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (predn A + ε + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
rewrite addn1 prednK //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3156)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3229)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3252)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (minn (A + ε + D tsk - D tsk_o) x)
subgoal 2 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
- have ->: minn (A + D tsk - D tsk_o) x = A + D tsk - D tsk_o.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 3256)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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
subgoal 2 (ID 3261) is:
rbf tsk_o (A + D tsk - D tsk_o) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
subgoal 3 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3256)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3265)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3280)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3261)
subgoal 1 (ID 3261) is:
rbf tsk_o (A + D tsk - D tsk_o) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
subgoal 2 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3261)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (minn (A + ε + D tsk - D tsk_o) x)
subgoal 2 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
try (move: (CASE); move⇒ /minn_idPl ->).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3361)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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)
subgoal 2 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
now apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3253)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
- have ->: minn (A + D tsk - D tsk_o) x = x.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3392)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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
subgoal 2 (ID 3397) is:
rbf tsk_o x == rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3392)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3446)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 < succn (A + D tsk) - D tsk_o
subgoal 2 (ID 3447) is:
D tsk_o <= A + D tsk
----------------------------------------------------------------------------- *)
+ now rewrite -[in X in _ ≤ X]addn1 -addnA [_ + 1]addnC addnA.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3447)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3480)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3397)
subgoal 1 (ID 3397) is:
rbf tsk_o x == rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3397)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
try (apply ltnW in CASE; move: CASE; move⇒ /minn_idPl; rewrite minnC ⇒ ->).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3649)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 x == rbf tsk_o x
----------------------------------------------------------------------------- *)
(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
now apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
is_in_search_space A.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2545)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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.
move: H_A_is_in_abstract_search_space ⇒ [INSP | [/andP [POSA LTL] [x [LTx INSP2]]]].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2559)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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
subgoal 2 (ID 2629) is:
is_in_search_space A
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2559)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2635)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2688)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2719)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2724)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2761)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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
subgoal 2 (ID 2762) is:
task_cost tsk <= task_request_bound_function tsk ε
----------------------------------------------------------------------------- *)
- by eapply leq_trans; eauto 2;
rewrite -(eqbool_to_eqprop H_job_of_tsk); apply H_valid_job_cost.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2762)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 using eqbool_to_eqprop.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2629)
subgoal 1 (ID 2629) is:
is_in_search_space A
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2629)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 < A
LTL : 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
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2629)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 < A
LTL : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2860)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 < A
LTL : 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].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3014)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 < A
LTL : 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3017)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (A - ε) x =
task_rbf (A + ε) - task_cost tsk + IBF A x
----------------------------------------------------------------------------- *)
rewrite subn1 addn1 prednK // -EQ1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3053)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (predn A) x =
task_rbf A - task_cost tsk + IBF A x
----------------------------------------------------------------------------- *)
apply/eqP; rewrite eqn_add2l eqn_add2l.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3118)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (predn A) x == bound_on_total_hep_workload A x
----------------------------------------------------------------------------- *)
apply: eq_sum_seq; intros tsk_o IN NEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3149)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (predn A + ε + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
rewrite addn1 prednK //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3156)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3229)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3252)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (minn (A + ε + D tsk - D tsk_o) x)
subgoal 2 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
- have ->: minn (A + D tsk - D tsk_o) x = A + D tsk - D tsk_o.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 3256)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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
subgoal 2 (ID 3261) is:
rbf tsk_o (A + D tsk - D tsk_o) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
subgoal 3 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3256)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3265)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3280)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3261)
subgoal 1 (ID 3261) is:
rbf tsk_o (A + D tsk - D tsk_o) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
subgoal 2 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3261)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (minn (A + ε + D tsk - D tsk_o) x)
subgoal 2 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
try (move: (CASE); move⇒ /minn_idPl ->).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3361)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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)
subgoal 2 (ID 3253) is:
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
now apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3253)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
- have ->: minn (A + D tsk - D tsk_o) x = x.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3392)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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
subgoal 2 (ID 3397) is:
rbf tsk_o x == rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3392)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 3446)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 < succn (A + D tsk) - D tsk_o
subgoal 2 (ID 3447) is:
D tsk_o <= A + D tsk
----------------------------------------------------------------------------- *)
+ now rewrite -[in X in _ ≤ X]addn1 -addnA [_ + 1]addnC addnA.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3447)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3480)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3397)
subgoal 1 (ID 3397) is:
rbf tsk_o x == rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3397)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 (minn (A + ε + D tsk - D tsk_o) x)
----------------------------------------------------------------------------- *)
try (apply ltnW in CASE; move: CASE; move⇒ /minn_idPl; rewrite minnC ⇒ ->).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 3649)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 A Δ) A
POSA : 0 < A
LTL : A < L
x : nat
LTx : x < L
INSP2 : task_rbf (A - ε + ε) - task_cost tsk + IBF (A - ε) x <>
task_rbf (A + ε) - task_cost tsk + IBF 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 x == rbf tsk_o x
----------------------------------------------------------------------------- *)
(* legacy: needed for mathcomp 1.10 & Coq 8.11 *)
now apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
Then, there exists solution for response-time recurrence (in the abstract sense).
Corollary correct_search_space:
∃ F,
A + F = task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) + IBF A (A + F) ∧
F + (task_cost tsk - task_run_to_completion_threshold tsk) ≤ R.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2558)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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,
A + F =
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
Proof.
edestruct H_R_is_maximum as [F [FIX NEQ]].
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2562)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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
subgoal 2 (ID 2572) is:
exists F0 : nat,
A + F0 =
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F0) /\
F0 + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply A_is_in_concrete_search_space.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2572)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 : A + F =
priority_inversion_bound +
(task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F)
NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
exists F0 : nat,
A + F0 =
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F0) /\
F0 + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- ∃ F; split; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2576)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 : A + F =
priority_inversion_bound +
(task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F)
NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
A + F =
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F)
----------------------------------------------------------------------------- *)
apply/eqP; rewrite {1}FIX.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2634)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 : A + F =
priority_inversion_bound +
(task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F)
NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
priority_inversion_bound +
(task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) ==
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F)
----------------------------------------------------------------------------- *)
by rewrite addnA [_ + priority_inversion_bound]addnC -!addnA.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End SolutionOfResponseTimeReccurenceExists.
End FillingOutHypothesesOfAbstractRTATheorem.
∃ F,
A + F = task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) + IBF A (A + F) ∧
F + (task_cost tsk - task_run_to_completion_threshold tsk) ≤ R.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2558)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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,
A + F =
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
Proof.
edestruct H_R_is_maximum as [F [FIX NEQ]].
(* ----------------------------------[ coqtop ]---------------------------------
2 focused subgoals
(shelved: 1) (ID 2562)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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
subgoal 2 (ID 2572) is:
exists F0 : nat,
A + F0 =
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F0) /\
F0 + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply A_is_in_concrete_search_space.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2572)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 : A + F =
priority_inversion_bound +
(task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F)
NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
exists F0 : nat,
A + F0 =
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F0) /\
F0 + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- ∃ F; split; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2576)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 : A + F =
priority_inversion_bound +
(task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F)
NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
A + F =
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F)
----------------------------------------------------------------------------- *)
apply/eqP; rewrite {1}FIX.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2634)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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 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 : A + F =
priority_inversion_bound +
(task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F)
NEQ : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
priority_inversion_bound +
(task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) ==
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F)
----------------------------------------------------------------------------- *)
by rewrite addnA [_ + priority_inversion_bound]addnC -!addnA.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
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.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2519)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := fun A R : duration =>
priority_inversion_bound + bound_on_total_hep_workload A R
: duration -> duration -> nat
============================
response_time_bounded_by tsk R
----------------------------------------------------------------------------- *)
Proof.
intros js ARRs TSKs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2523)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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: (posnP (@job_cost _ H4 js)) ⇒ [ZERO|POS].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2540)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
ZERO : job_cost js = 0
============================
job_response_time_bound sched js R
subgoal 2 (ID 2541) is:
job_response_time_bound sched js R
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2540)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
ZERO : job_cost js = 0
============================
job_response_time_bound sched js R
----------------------------------------------------------------------------- *)
by rewrite /job_response_time_bound /completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2541)
subgoal 1 (ID 2541) is:
job_response_time_bound sched js R
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2541)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
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 A R) (L0 := L); eauto 3.
(* ----------------------------------[ coqtop ]---------------------------------
5 subgoals (ID 2583)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
work_conserving arr_seq sched tsk interference interfering_workload
subgoal 2 (ID 2585) is:
interference_and_workload_consistent_with_sequential_tasks arr_seq sched tsk
interference interfering_workload
subgoal 3 (ID 2586) is:
busy_intervals_are_bounded_by arr_seq sched tsk interference
interfering_workload L
subgoal 4 (ID 2587) is:
task_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 5 (ID 2588) is:
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply instantiated_i_and_w_are_coherent_with_schedule.
(* ----------------------------------[ coqtop ]---------------------------------
4 subgoals (ID 2585)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
interference_and_workload_consistent_with_sequential_tasks arr_seq sched
tsk interference interfering_workload
subgoal 2 (ID 2586) is:
busy_intervals_are_bounded_by arr_seq sched tsk interference
interfering_workload L
subgoal 3 (ID 2587) is:
task_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 4 (ID 2588) is:
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply instantiated_interference_and_workload_consistent_with_sequential_tasks.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2586)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
busy_intervals_are_bounded_by arr_seq sched tsk interference
interfering_workload L
subgoal 2 (ID 2587) is:
task_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 3 (ID 2588) is:
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply instantiated_busy_intervals_are_bounded.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2587)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
task_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 2 (ID 2588) is:
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply instantiated_task_interference_is_bounded.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2588)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- eapply correct_search_space; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2610)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
job_of_task tsk js
----------------------------------------------------------------------------- *)
by apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End AbstractRTAforEDFwithArrivalCurves.
response_time_bounded_by tsk R.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2519)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := fun A R : duration =>
priority_inversion_bound + bound_on_total_hep_workload A R
: duration -> duration -> nat
============================
response_time_bounded_by tsk R
----------------------------------------------------------------------------- *)
Proof.
intros js ARRs TSKs.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2523)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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: (posnP (@job_cost _ H4 js)) ⇒ [ZERO|POS].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2540)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
ZERO : job_cost js = 0
============================
job_response_time_bound sched js R
subgoal 2 (ID 2541) is:
job_response_time_bound sched js R
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2540)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
ZERO : job_cost js = 0
============================
job_response_time_bound sched js R
----------------------------------------------------------------------------- *)
by rewrite /job_response_time_bound /completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2541)
subgoal 1 (ID 2541) is:
job_response_time_bound sched js R
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2541)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
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 A R) (L0 := L); eauto 3.
(* ----------------------------------[ coqtop ]---------------------------------
5 subgoals (ID 2583)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
work_conserving arr_seq sched tsk interference interfering_workload
subgoal 2 (ID 2585) is:
interference_and_workload_consistent_with_sequential_tasks arr_seq sched tsk
interference interfering_workload
subgoal 3 (ID 2586) is:
busy_intervals_are_bounded_by arr_seq sched tsk interference
interfering_workload L
subgoal 4 (ID 2587) is:
task_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 5 (ID 2588) is:
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply instantiated_i_and_w_are_coherent_with_schedule.
(* ----------------------------------[ coqtop ]---------------------------------
4 subgoals (ID 2585)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
interference_and_workload_consistent_with_sequential_tasks arr_seq sched
tsk interference interfering_workload
subgoal 2 (ID 2586) is:
busy_intervals_are_bounded_by arr_seq sched tsk interference
interfering_workload L
subgoal 3 (ID 2587) is:
task_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 4 (ID 2588) is:
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply instantiated_interference_and_workload_consistent_with_sequential_tasks.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 2586)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
busy_intervals_are_bounded_by arr_seq sched tsk interference
interfering_workload L
subgoal 2 (ID 2587) is:
task_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 3 (ID 2588) is:
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply instantiated_busy_intervals_are_bounded.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2587)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
task_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload (fun=> (fun A : duration => [eta IBF A]))
subgoal 2 (ID 2588) is:
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- by apply instantiated_task_interference_is_bounded.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2588)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
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 A0 Δ) A ->
exists F : duration,
A + F =
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
IBF A (A + F) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
- eapply correct_search_space; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2610)
Task : TaskType
H : TaskCost Task
H0 : TaskDeadline Task
H1 : TaskRunToCompletionThreshold Task
Job : JobType
H2 : JobTask Job Task
H3 : JobArrival Job
H4 : JobCost Job
H5 : JobPreemptable Job
D := [eta task_deadline] : Task -> duration
EDF := edf.EDF Job : JLFP_policy Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
work_conserving_ab := work_conserving arr_seq sched
: Task -> (Job -> instant -> bool) -> (Job -> instant -> duration) -> Prop
work_conserving_cl := work_conserving.work_conserving arr_seq sched : Prop
H_work_conserving : work_conserving_cl
H_sequential_tasks : sequential_tasks arr_seq sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts
H6 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
rbf := task_request_bound_function : Task -> duration -> nat
task_rbf := rbf tsk : duration -> nat
total_rbf := total_request_bound_function ts : duration -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
number_of_task_arrivals := arrivals.number_of_task_arrivals arr_seq
: Task -> instant -> instant -> nat
priority_inversion_bound : duration
H_priority_inversion_is_bounded : priority_inversion_is_bounded_by arr_seq
sched tsk priority_inversion_bound
L : duration
H_L_positive : 0 < L
H_fixed_point : L = total_rbf L
bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn (A + ε + D tsk - D tsk_o) Δ)
: duration -> duration -> nat
R : duration
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_run_to_completion_threshold tsk)) +
bound_on_total_hep_workload A (A + F) /\
F +
(task_cost tsk - task_run_to_completion_threshold tsk) <=
R
interference := fun j : Job => [eta ideal_jlfp_rta.interference sched j]
: Job -> instant -> bool
interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload arr_seq
sched j] : Job -> instant -> nat
IBF := 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
POS : 0 < job_cost js
============================
job_of_task tsk js
----------------------------------------------------------------------------- *)
by apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End AbstractRTAforEDFwithArrivalCurves.