Library rt.restructuring.analysis.abstract.core.abstract_seq_rta
(* ----------------------------------[ coqtop ]---------------------------------
Welcome to Coq 8.10.1 (October 2019)
----------------------------------------------------------------------------- *)
From rt.util Require Import all.
From rt.restructuring.behavior Require Import all.
From rt.restructuring.model Require Import job task.
From rt.restructuring.model.preemption Require Import rtc_threshold.valid_rtct
valid_model job.parameters task.parameters.
From rt.restructuring.analysis.basic_facts.preemption Require Import
rtc_threshold.job_preemptable.
From rt.restructuring.model.arrival Require Import arrival_curves.
From rt.restructuring.model.schedule Require Import sequential.
From rt.restructuring.analysis Require Import
schedulability ideal_schedule workload task_schedule arrival.workload_bound arrival.rbf.
From rt.restructuring.analysis.basic_facts Require Import all task_arrivals.
From rt.restructuring.analysis.abstract.core Require Import definitions reduction_of_search_space
sufficient_condition_for_run_to_completion_threshold abstract_rta.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
Abstract Response-Time Analysis with sequential tasks
In this section we propose the general framework for response-time analysis (RTA) of uniprocessor scheduling of real-time tasks with arbitrary arrival models and sequential tasks.
Consider any type of tasks ...
... 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}.
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 nor 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.
Assume that the job costs are no larger than the task costs.
Consider an arbitrary task set.
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.
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.
Assume we are provided with abstract functions for interference and interfering workload.
Variable interference : Job → instant → bool.
Variable interfering_workload : Job → instant → duration.
Variable interfering_workload : Job → instant → duration.
Let's define some local names for clarity.
Let task_rbf := task_request_bound_function tsk.
Let busy_interval := busy_interval sched interference interfering_workload.
Let arrivals_between := arrivals_between arr_seq.
Let service_of_jobs_at := service_of_jobs_at sched.
Let task_workload_between := task_workload_between arr_seq tsk.
Let task_service_of_jobs_in := task_service_of_jobs_in sched tsk.
Let response_time_bounded_by := task_response_time_bound arr_seq sched.
Let busy_interval := busy_interval sched interference interfering_workload.
Let arrivals_between := arrivals_between arr_seq.
Let service_of_jobs_at := service_of_jobs_at sched.
Let task_workload_between := task_workload_between arr_seq tsk.
Let task_service_of_jobs_in := task_service_of_jobs_in sched tsk.
Let response_time_bounded_by := task_response_time_bound arr_seq sched.
In this section, we introduce a few new definitions to make it easier
to express the new bound of the worst-case execution time.
When assuming sequential tasks, we can introduce an additional hypothesis that
ensures that the values of interference and workload remain consistent. It states
that any of tsk's job, that arrived before the busy interval, should be
completed by the beginning of the busy interval.
Definition interference_and_workload_consistent_with_sequential_tasks :=
∀ (j : Job) (t1 t2 : instant),
arrives_in arr_seq j →
job_task j = tsk →
job_cost j > 0 →
busy_interval j t1 t2 →
task_workload_between 0 t1 = task_service_of_jobs_in (arrivals_between 0 t1) 0 t1.
∀ (j : Job) (t1 t2 : instant),
arrives_in arr_seq j →
job_task j = tsk →
job_cost j > 0 →
busy_interval j t1 t2 →
task_workload_between 0 t1 = task_service_of_jobs_in (arrivals_between 0 t1) 0 t1.
Next we introduce the notion of task interference. Intuitively, task tsk incurs
interference when some of the jobs of task tsk incur interference. As a result,
tsk cannot make any progress. More formally, task tsk experiences interference at
a time instant time t, if at time t task tsk is not scheduled and there exists
a job of tsk that (1) experiences interference and (2) has arrived before some
time instant [upper_bound].
It is important to note two subtle points: according to our semantics of the
interference function, jobs from the same task can cause interference to each other.
In the definition of interference of a task we want to avoid such situations. That
is why we use the term [~~ task_scheduled_at tsk t].
Moreover, in order to make the definition constructive, we introduce an upper bound
on the arrival time of jobs from task tsk. As a result, we need to consider only a
finite number of jobs. For the function to produce the correct values it is enough
to specify a sufficiently large upper_bound. Usually as upper_bound one can use the
end of the corresponding busy interval.
Definition task_interference_received_before (tsk : Task) (upper_bound : instant) (t : instant) :=
(~~ task_scheduled_at sched tsk t)
&& has (fun j ⇒ interference j t) (task_arrivals_before arr_seq tsk upper_bound).
(~~ task_scheduled_at sched tsk t)
&& has (fun j ⇒ interference j t) (task_arrivals_before arr_seq tsk upper_bound).
Next we define the cumulative task interference.
Definition cumul_task_interference tsk upper_bound t1 t2 :=
\sum_(t1 ≤ t < t2) task_interference_received_before tsk upper_bound t.
\sum_(t1 ≤ t < t2) task_interference_received_before tsk upper_bound t.
We say that task interference is bounded by task_interference_bound_function (tIBF)
iff for any job j of task tsk cumulative _task_ interference within the interval
[t1, t1 + R) is bounded by function tIBF(tsk, A, R).
Note that this definition is almost the same as the definition of job_interference_is_bounded_by
from the non-nesessary-sequential case. However, in this case we ignore the
interference that comes from jobs from the same task.
Definition task_interference_is_bounded_by
(task_interference_bound_function : Task → duration → duration → duration) :=
∀ j R t1 t2,
arrives_in arr_seq j →
job_task j = tsk →
t1 + R < t2 →
~~ completed_by sched j (t1 + R) →
busy_interval j t1 t2 →
let offset := job_arrival j - t1 in
cumul_task_interference tsk t2 t1 (t1 + R) ≤ task_interference_bound_function tsk offset R.
End Definitions.
(task_interference_bound_function : Task → duration → duration → duration) :=
∀ j R t1 t2,
arrives_in arr_seq j →
job_task j = tsk →
t1 + R < t2 →
~~ completed_by sched j (t1 + R) →
busy_interval j t1 t2 →
let offset := job_arrival j - t1 in
cumul_task_interference tsk t2 t1 (t1 + R) ≤ task_interference_bound_function tsk offset R.
End Definitions.
In this section, we prove that the maximum among the solutions of the
response-time bound recurrence is a response-time bound for tsk.
For simplicity, let's define some local names.
Let cumul_interference := cumul_interference interference.
Let cumul_workload := cumul_interfering_workload interfering_workload.
Let cumul_task_interference := cumul_task_interference tsk.
Let cumul_workload := cumul_interfering_workload interfering_workload.
Let cumul_task_interference := cumul_task_interference tsk.
We assume that the schedule is work-conserving.
Unlike the previous theorem [uniprocessor_response_time_bound], we assume
that (1) tasks are sequential, moreover (2) functions interference and
interfering_workload are consistent with the hypothesis of sequential tasks.
Hypothesis H_sequential_tasks : sequential_tasks sched.
Hypothesis H_interference_and_workload_consistent_with_sequential_tasks:
interference_and_workload_consistent_with_sequential_tasks.
Hypothesis H_interference_and_workload_consistent_with_sequential_tasks:
interference_and_workload_consistent_with_sequential_tasks.
Assume we have a constant L which bounds the busy interval of any of tsk's jobs.
Variable L : duration.
Hypothesis H_busy_interval_exists:
busy_intervals_are_bounded_by arr_seq sched tsk interference interfering_workload L.
Hypothesis H_busy_interval_exists:
busy_intervals_are_bounded_by arr_seq sched tsk interference interfering_workload L.
Next, we assume that task_interference_bound_function is a bound on interference incurred by the task.
Variable task_interference_bound_function : Task → duration → duration → duration.
Hypothesis H_task_interference_is_bounded:
task_interference_is_bounded_by task_interference_bound_function.
Hypothesis H_task_interference_is_bounded:
task_interference_is_bounded_by task_interference_bound_function.
Given any job j of task tsk that arrives exactly A units after the beginning of the busy
interval, the bound on the total interference incurred by j within an interval of length Δ
is no greater than [task_rbf (A + ε) - task_cost tsk + task's IBF Δ]. Note that in case of
sequential tasks the bound consists of two parts: (1) the part that bounds the interference
received from other jobs of task tsk -- [task_rbf (A + ε) - task_cost tsk] and (2) any other
interferece that is bounded by task_IBF(tsk, A, Δ).
Let total_interference_bound (tsk : Task) (A Δ : duration) :=
task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A Δ.
task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A Δ.
Note that since we consider the modified interference bound function, the search space has
also changed. One can see that the new search space is guaranteed to include any A for which
[task_rbf (A) ≠ task_rbf (A + ε)], since this implies the fact that
[total_interference_bound (tsk, A, Δ) ≠ total_interference_bound (tsk, A + ε, Δ)].
Consider any value R, and assume that for any relative arrival time A from the search
space there is a solution F of the response-time recurrence that is bounded by R. In
contrast to the formula in "non-sequential" Abstract RTA, assuming that tasks are
sequential leads to a more precise response-time bound. Now we can explicitly express
the interference caused by other jobs of the task under consideration.
To understand the right part of the fixpoint in the equation it is helpful to note
that the bound on the total interference (bound_of_total_interference) is equal to
[task_rbf (A + ε) - task_cost tsk + tIBF tsk A Δ]. Besides, a job must receive
enough service to become non-preemptive [task_lock_in_service tsk]. The sum of
these two quantities is exactly the right-hand side of the equation.
Variable R : nat.
Hypothesis H_R_is_maximum_seq:
∀ (A : duration),
is_in_search_space_seq A →
∃ (F : duration),
A + F = (task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk))
+ task_interference_bound_function tsk A (A + F) ∧
F + (task_cost tsk - task_run_to_completion_threshold tsk) ≤ R.
Hypothesis H_R_is_maximum_seq:
∀ (A : duration),
is_in_search_space_seq A →
∃ (F : duration),
A + F = (task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk))
+ task_interference_bound_function tsk A (A + F) ∧
F + (task_cost tsk - task_run_to_completion_threshold tsk) ≤ R.
In this section we prove a few simple lemmas about the completion of jobs from the task
considering the busy interval of the job under consideration.
Consider any two jobs j1 j2 of tsk.
Variable j1 j2 : Job.
Hypothesis H_j1_arrives: arrives_in arr_seq j1.
Hypothesis H_j2_arrives: arrives_in arr_seq j2.
Hypothesis H_j1_from_tsk: job_task j1 = tsk.
Hypothesis H_j2_from_tsk: job_task j2 = tsk.
Hypothesis H_j1_cost_positive: job_cost_positive j1.
Hypothesis H_j1_arrives: arrives_in arr_seq j1.
Hypothesis H_j2_arrives: arrives_in arr_seq j2.
Hypothesis H_j1_from_tsk: job_task j1 = tsk.
Hypothesis H_j2_from_tsk: job_task j2 = tsk.
Hypothesis H_j1_cost_positive: job_cost_positive j1.
Consider the busy interval [t1, t2) of job j1.
We prove that if a job from task tsk arrived before the beginning of the busy
interval, then it must be completed before the beginning of the busy interval
Lemma completed_before_beginning_of_busy_interval:
job_arrival j2 < t1 →
completed_by sched j2 t1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 289)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
============================
job_arrival j2 < t1 -> completed_by sched j2 t1
----------------------------------------------------------------------------- *)
Proof.
move ⇒ JA; move: (H_j2_from_tsk) ⇒ /eqP TSK2eq.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
============================
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
move: (posnP (@job_cost _ H3 j2)) ⇒ [ZERO|POS].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 367)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
ZERO : job_cost j2 = 0
============================
completed_by sched j2 t1
subgoal 2 (ID 368) is:
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 367)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
ZERO : job_cost j2 = 0
============================
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
by rewrite /completed_by /service.completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 368)
subgoal 1 (ID 368) is:
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 368)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
POS : 0 < job_cost j2
============================
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
move: (H_interference_and_workload_consistent_with_sequential_tasks
j1 t1 t2 H_j1_arrives H_j1_from_tsk H_j1_cost_positive H_busy_interval) ⇒ SWEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 386)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
POS : 0 < job_cost j2
SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in (arrivals_between 0 t1) 0 t1
============================
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
eapply all_jobs_have_completed_equiv_workload_eq_service
with (j := j2) in SWEQ; eauto 2; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
POS : 0 < job_cost j2
SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in (arrivals_between 0 t1) 0 t1
H6 : forall arr_seq : arrival_sequence Job,
consistent_arrival_times arr_seq ->
forall sched : schedule (processor_state Job),
jobs_must_arrive_to_execute sched ->
completed_jobs_dont_execute sched ->
forall (P : Job -> bool) (t1 t2 t_compl : instant),
workload_of_jobs P (arrival_sequence.arrivals_between arr_seq t1 t2) =
service_of_jobs sched P
(arrival_sequence.arrivals_between arr_seq t1 t2) t1 t_compl ->
forall j : Job,
j \in arrival_sequence.arrivals_between arr_seq t1 t2 ->
P j -> completed_by sched j t_compl
============================
j2 \in arrival_sequence.arrivals_between arr_seq 0 t1
----------------------------------------------------------------------------- *)
by apply arrived_between_implies_in_arrivals.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
job_arrival j2 < t1 →
completed_by sched j2 t1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 289)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
============================
job_arrival j2 < t1 -> completed_by sched j2 t1
----------------------------------------------------------------------------- *)
Proof.
move ⇒ JA; move: (H_j2_from_tsk) ⇒ /eqP TSK2eq.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
============================
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
move: (posnP (@job_cost _ H3 j2)) ⇒ [ZERO|POS].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 367)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
ZERO : job_cost j2 = 0
============================
completed_by sched j2 t1
subgoal 2 (ID 368) is:
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 367)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
ZERO : job_cost j2 = 0
============================
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
by rewrite /completed_by /service.completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 368)
subgoal 1 (ID 368) is:
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 368)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
POS : 0 < job_cost j2
============================
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
move: (H_interference_and_workload_consistent_with_sequential_tasks
j1 t1 t2 H_j1_arrives H_j1_from_tsk H_j1_cost_positive H_busy_interval) ⇒ SWEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 386)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
POS : 0 < job_cost j2
SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in (arrivals_between 0 t1) 0 t1
============================
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
eapply all_jobs_have_completed_equiv_workload_eq_service
with (j := j2) in SWEQ; eauto 2; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
JA : job_arrival j2 < t1
TSK2eq : job_task j2 == tsk
POS : 0 < job_cost j2
SWEQ : task_workload_between 0 t1 =
task_service_of_jobs_in (arrivals_between 0 t1) 0 t1
H6 : forall arr_seq : arrival_sequence Job,
consistent_arrival_times arr_seq ->
forall sched : schedule (processor_state Job),
jobs_must_arrive_to_execute sched ->
completed_jobs_dont_execute sched ->
forall (P : Job -> bool) (t1 t2 t_compl : instant),
workload_of_jobs P (arrival_sequence.arrivals_between arr_seq t1 t2) =
service_of_jobs sched P
(arrival_sequence.arrivals_between arr_seq t1 t2) t1 t_compl ->
forall j : Job,
j \in arrival_sequence.arrivals_between arr_seq t1 t2 ->
P j -> completed_by sched j t_compl
============================
j2 \in arrival_sequence.arrivals_between arr_seq 0 t1
----------------------------------------------------------------------------- *)
by apply arrived_between_implies_in_arrivals.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
Next we prove that if a job is pending after the beginning
of the busy interval [t1, t2) then it arrives after t1.
Lemma arrives_after_beginning_of_busy_interval:
∀ t,
t1 ≤ t →
pending sched j2 t →
arrived_between j2 t1 t.+1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 298)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
============================
forall t : nat,
t1 <= t -> pending sched j2 t -> arrived_between j2 t1 (succn t)
----------------------------------------------------------------------------- *)
Proof.
intros t GE PEND.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 301)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
============================
arrived_between j2 t1 (succn t)
----------------------------------------------------------------------------- *)
rewrite /arrived_between; apply/andP; split; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 333)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
============================
job_arrival j2 < succn t
subgoal 2 (ID 332) is:
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 333)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
============================
job_arrival j2 < succn t
----------------------------------------------------------------------------- *)
by move: PEND ⇒ /andP [ARR _]; rewrite ltnS.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 332)
subgoal 1 (ID 332) is:
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 332)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
============================
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
rewrite leqNgt; apply/negP; intros LT.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 405)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
LT : job_arrival j2 < t1
============================
False
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [AFR1 AFR2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 476)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
LT : job_arrival j2 < t1
AFR1 : t1 <= job_arrival j1
AFR2 : job_arrival j1 < t2
QT : quiet_time sched interference interfering_workload j1 t1
============================
False
----------------------------------------------------------------------------- *)
have L12 := completed_before_beginning_of_busy_interval LT.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 481)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
LT : job_arrival j2 < t1
AFR1 : t1 <= job_arrival j1
AFR2 : job_arrival j1 < t2
QT : quiet_time sched interference interfering_workload j1 t1
L12 : completed_by sched j2 t1
============================
False
----------------------------------------------------------------------------- *)
apply completion_monotonic with (t' := t) in L12; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 486)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
LT : job_arrival j2 < t1
AFR1 : t1 <= job_arrival j1
AFR2 : job_arrival j1 < t2
QT : quiet_time sched interference interfering_workload j1 t1
L12 : completed_by sched j2 t
============================
False
----------------------------------------------------------------------------- *)
by move: PEND ⇒ /andP [_ /negP T2].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End CompletionOfJobsFromSameTask.
∀ t,
t1 ≤ t →
pending sched j2 t →
arrived_between j2 t1 t.+1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 298)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
============================
forall t : nat,
t1 <= t -> pending sched j2 t -> arrived_between j2 t1 (succn t)
----------------------------------------------------------------------------- *)
Proof.
intros t GE PEND.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 301)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
============================
arrived_between j2 t1 (succn t)
----------------------------------------------------------------------------- *)
rewrite /arrived_between; apply/andP; split; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 333)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
============================
job_arrival j2 < succn t
subgoal 2 (ID 332) is:
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 333)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
============================
job_arrival j2 < succn t
----------------------------------------------------------------------------- *)
by move: PEND ⇒ /andP [ARR _]; rewrite ltnS.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 332)
subgoal 1 (ID 332) is:
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 332)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
============================
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
rewrite leqNgt; apply/negP; intros LT.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 405)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
LT : job_arrival j2 < t1
============================
False
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [AFR1 AFR2] [QT _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 476)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
LT : job_arrival j2 < t1
AFR1 : t1 <= job_arrival j1
AFR2 : job_arrival j1 < t2
QT : quiet_time sched interference interfering_workload j1 t1
============================
False
----------------------------------------------------------------------------- *)
have L12 := completed_before_beginning_of_busy_interval LT.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 481)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
LT : job_arrival j2 < t1
AFR1 : t1 <= job_arrival j1
AFR2 : job_arrival j1 < t2
QT : quiet_time sched interference interfering_workload j1 t1
L12 : completed_by sched j2 t1
============================
False
----------------------------------------------------------------------------- *)
apply completion_monotonic with (t' := t) in L12; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 486)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j1, j2 : Job
H_j1_arrives : arrives_in arr_seq j1
H_j2_arrives : arrives_in arr_seq j2
H_j1_from_tsk : job_task j1 = tsk
H_j2_from_tsk : job_task j2 = tsk
H_j1_cost_positive : job_cost_positive j1
t1, t2 : instant
H_busy_interval : busy_interval j1 t1 t2
t : nat
GE : t1 <= t
PEND : pending sched j2 t
LT : job_arrival j2 < t1
AFR1 : t1 <= job_arrival j1
AFR2 : job_arrival j1 < t2
QT : quiet_time sched interference interfering_workload j1 t1
L12 : completed_by sched j2 t
============================
False
----------------------------------------------------------------------------- *)
by move: PEND ⇒ /andP [_ /negP T2].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End CompletionOfJobsFromSameTask.
Since we are going to use the [uniprocessor_response_time_bound] theorem to prove
the theorem of this section, we have to show that all the hypotheses are satisfied.
Namely, we need to show that hypotheses [H_sequential_tasks, H_i_w_are_task_consistent
and H_task_interference_is_bounded_by] imply [H_job_interference_is_bounded], and the
fact that [H_R_is_maximum_seq] implies [H_R_is_maximum].
In this section we show that there exists a bound for cumulative interference for any
job of task tsk, i.e., the hypothesis H_job_interference_is_bounded holds.
Consider any 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.
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 the busy interval [t1, t2) of job j.
Let's define A as a relative arrival time of job j (with respect to time t1).
Consider an arbitrary time x ...
... such that (t1 + x) is inside the busy interval...
... and job j is not completed by time (t1 + x).
In this section, we show that the cumulative interference of job j in the interval [t1, t1 + x)
is bounded by the sum of the task workload in the interval [t1, t1 + A + ε) and the cumulative
interference of j's task in the interval [t1, t1 + x). Note that the task workload is computed
only on the interval [t1, t1 + A + ε). Thanks to the hypothesis about sequential tasks, jobs of
task tsk that arrive after [t1 + A + ε] cannot interfere with j.
We start by proving a simpler analog of the lemma which states that at
any time instant t ∈ [t1, t1 + x) the sum of [interference j t] and
[scheduled_at j t] is no larger than the sum of [the service received
by jobs of task tsk at time t] and [task_iterference tsk t].
Next we consider 4 cases.
Consider an arbitrary time instant t ∈ [t1, t1 + x).
Assume the processor is idle at time t.
In case when the processor is idle, one can show that
[interference j t = 1, scheduled_at j t = 0]. But since
interference doesn't come from a job of task tsk
[task_interferece tsk = 1]. Which reduces to [1 ≤ 1].
Lemma interference_plus_sched_le_serv_of_task_plus_task_interference_idle:
interference j t + scheduled_at sched j t ≤
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 292)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
move: (H_busy_interval) ⇒ [[/andP [BUS LT] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 353)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
rewrite /cumul_task_interference /definitions.cumul_interference
/Sequential_Abstract_RTA.cumul_task_interference /task_interference_received_before
/task_scheduled_at /task_schedule.task_scheduled_at /service_of_jobs_at
/service_of_jobs.service_of_jobs_at/= scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 389)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite !H_idle/=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 392)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + 0 <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0) 0 +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite big1_eq addn0 add0n.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 410)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t <=
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
case INT: (interference j t); last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 483)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
INT : interference j t = true
============================
true <= has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
simpl; rewrite lt0b.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 553)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
INT : interference j t = true
============================
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
apply/hasP; ∃ j; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 583)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
INT : interference j t = true
============================
j \in task_arrivals_before arr_seq tsk t2
----------------------------------------------------------------------------- *)
by rewrite mem_filter; apply/andP; split;
[rewrite H_job_of_tsk | eapply arrived_between_implies_in_arrivals; eassumption].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case1.
Section Case2.
interference j t + scheduled_at sched j t ≤
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 292)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
move: (H_busy_interval) ⇒ [[/andP [BUS LT] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 353)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
rewrite /cumul_task_interference /definitions.cumul_interference
/Sequential_Abstract_RTA.cumul_task_interference /task_interference_received_before
/task_scheduled_at /task_schedule.task_scheduled_at /service_of_jobs_at
/service_of_jobs.service_of_jobs_at/= scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 389)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite !H_idle/=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 392)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + 0 <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0) 0 +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite big1_eq addn0 add0n.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 410)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t <=
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
case INT: (interference j t); last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 483)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
INT : interference j t = true
============================
true <= has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
simpl; rewrite lt0b.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 553)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
INT : interference j t = true
============================
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
apply/hasP; ∃ j; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 583)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_idle : sched t = None
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
INT : interference j t = true
============================
j \in task_arrivals_before arr_seq tsk t2
----------------------------------------------------------------------------- *)
by rewrite mem_filter; apply/andP; split;
[rewrite H_job_of_tsk | eapply arrived_between_implies_in_arrivals; eassumption].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case1.
Section Case2.
Assume a job j' from another task is scheduled at time t.
Variable j' : Job.
Hypothesis H_sched : sched t = Some j'.
Hypothesis H_not_job_of_tsk : job_task j' != tsk.
Hypothesis H_sched : sched t = Some j'.
Hypothesis H_not_job_of_tsk : job_task j' != tsk.
If a job j' from another task is scheduled at time t,
then [interference j t = 1, scheduled_at j t = 0]. But
since interference doesn't come from a job of task tsk
[task_interferece tsk = 1]. Which reduces to [1 ≤ 1].
Lemma interference_plus_sched_le_serv_of_task_plus_task_interference_task:
interference j t + scheduled_at sched j t ≤
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 296)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
move: (H_busy_interval) ⇒ [[/andP [BUS LT] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 357)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
rewrite /cumul_task_interference /definitions.cumul_interference
/Sequential_Abstract_RTA.cumul_task_interference /task_interference_received_before
/task_scheduled_at /task_schedule.task_scheduled_at /service_of_jobs_at
/service_of_jobs.service_of_jobs_at scheduled_at_def/=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 393)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
have ARRs: arrives_in arr_seq j'; first by apply H_jobs_come_from_arrival_sequence with t; rewrite scheduled_at_def; apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 397)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite H_sched H_not_job_of_tsk; simpl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 439)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t + (Some j' == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite (negbTE (option_inj_neq (neqprop_to_neqbool
(diseq (fun j ⇒ job_task j = tsk) _ _
(neqbool_to_neqprop H_not_job_of_tsk) H_job_of_tsk)))) addn0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 492)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
have ZERO: \sum_(i <- arrivals_between t1 (t1 + A + ε) | job_task i == tsk) (Some j' == Some i) = 0.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 508)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_task i == tsk)
(Some j' == Some i) = 0
subgoal 2 (ID 510) is:
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 508)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_task i == tsk)
(Some j' == Some i) = 0
----------------------------------------------------------------------------- *)
apply big1; move ⇒ j2 /eqP TSK2; apply/eqP; rewrite eqb0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 604)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
j2 : Job
TSK2 : job_task j2 = tsk
============================
Some j' != Some j2
----------------------------------------------------------------------------- *)
apply option_inj_neq, neqprop_to_neqbool, (diseq (fun j ⇒ job_task j = tsk) _ _
(neqbool_to_neqprop H_not_job_of_tsk) TSK2).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 510)
subgoal 1 (ID 510) is:
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 510)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ZERO : \sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_task i == tsk) (Some j' == Some i) = 0
============================
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite ZERO ?addn0 add0n; simpl; clear ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 641)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t <=
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
case INT: (interference j t); last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 717)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
INT : interference j t = true
============================
true <= has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
simpl; rewrite lt0b.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 790)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
INT : interference j t = true
============================
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
apply/hasP; ∃ j; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 820)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
INT : interference j t = true
============================
j \in task_arrivals_before arr_seq tsk t2
----------------------------------------------------------------------------- *)
by rewrite mem_filter; apply/andP; split;
[rewrite H_job_of_tsk | eapply arrived_between_implies_in_arrivals; eassumption].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case2.
Section Case3.
interference j t + scheduled_at sched j t ≤
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 296)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
move: (H_busy_interval) ⇒ [[/andP [BUS LT] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 357)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
rewrite /cumul_task_interference /definitions.cumul_interference
/Sequential_Abstract_RTA.cumul_task_interference /task_interference_received_before
/task_scheduled_at /task_schedule.task_scheduled_at /service_of_jobs_at
/service_of_jobs.service_of_jobs_at scheduled_at_def/=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 393)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
have ARRs: arrives_in arr_seq j'; first by apply H_jobs_come_from_arrival_sequence with t; rewrite scheduled_at_def; apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 397)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite H_sched H_not_job_of_tsk; simpl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 439)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t + (Some j' == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite (negbTE (option_inj_neq (neqprop_to_neqbool
(diseq (fun j ⇒ job_task j = tsk) _ _
(neqbool_to_neqprop H_not_job_of_tsk) H_job_of_tsk)))) addn0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 492)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
have ZERO: \sum_(i <- arrivals_between t1 (t1 + A + ε) | job_task i == tsk) (Some j' == Some i) = 0.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 508)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_task i == tsk)
(Some j' == Some i) = 0
subgoal 2 (ID 510) is:
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 508)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_task i == tsk)
(Some j' == Some i) = 0
----------------------------------------------------------------------------- *)
apply big1; move ⇒ j2 /eqP TSK2; apply/eqP; rewrite eqb0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 604)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
j2 : Job
TSK2 : job_task j2 = tsk
============================
Some j' != Some j2
----------------------------------------------------------------------------- *)
apply option_inj_neq, neqprop_to_neqbool, (diseq (fun j ⇒ job_task j = tsk) _ _
(neqbool_to_neqprop H_not_job_of_tsk) TSK2).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 510)
subgoal 1 (ID 510) is:
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 510)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ZERO : \sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_task i == tsk) (Some j' == Some i) = 0
============================
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0) +
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite ZERO ?addn0 add0n; simpl; clear ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 641)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t <=
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
case INT: (interference j t); last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 717)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
INT : interference j t = true
============================
true <= has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
simpl; rewrite lt0b.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 790)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
INT : interference j t = true
============================
has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
apply/hasP; ∃ j; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 820)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' != tsk
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
INT : interference j t = true
============================
j \in task_arrivals_before arr_seq tsk t2
----------------------------------------------------------------------------- *)
by rewrite mem_filter; apply/andP; split;
[rewrite H_job_of_tsk | eapply arrived_between_implies_in_arrivals; eassumption].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case2.
Section Case3.
Assume a job j' (different from j) of task tsk is scheduled at time t.
Variable j' : Job.
Hypothesis H_sched : sched t = Some j'.
Hypothesis H_not_job_of_tsk : job_task j' == tsk.
Hypothesis H_j_neq_j' : j != j'.
Hypothesis H_sched : sched t = Some j'.
Hypothesis H_not_job_of_tsk : job_task j' == tsk.
Hypothesis H_j_neq_j' : j != j'.
If a job j' (different from j) of task tsk is scheduled at time t, then
[interference j t = 1, scheduled_at j t = 0]. Moreover, since interference
comes from a job of the same task [task_interferece tsk = 0]. However,
in this case [service_of_jobs of tsk = 1]. Which reduces to [1 ≤ 1].
Lemma interference_plus_sched_le_serv_of_task_plus_task_interference_job:
interference j t + scheduled_at sched j t ≤
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
move: (H_busy_interval) ⇒ [[/andP [BUS LT] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 358)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
rewrite /cumul_task_interference /definitions.cumul_interference
/Sequential_Abstract_RTA.cumul_task_interference /task_interference_received_before
/task_scheduled_at /task_schedule.task_scheduled_at /service_of_jobs_at
/service_of_jobs.service_of_jobs_at scheduled_at_def/=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 394)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
have ARRs: arrives_in arr_seq j'; first by apply H_jobs_come_from_arrival_sequence with t; rewrite scheduled_at_def; apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 398)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite H_sched H_not_job_of_tsk addn0; simpl;
rewrite [Some j' == Some j](negbTE (option_inj_neq (neq_sym H_j_neq_j'))) addn0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 470)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
replace (interference j t) with true; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 472)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
true = interference j t
subgoal 2 (ID 474) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 472)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
true = interference j t
----------------------------------------------------------------------------- *)
have NEQT: t1 ≤ t < t2.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 476)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
t1 <= t < t2
subgoal 2 (ID 478) is:
true = interference j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 476)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
t1 <= t < t2
----------------------------------------------------------------------------- *)
by move: H_t_in_interval ⇒ /andP [NEQ1 NEQ2]; apply/andP; split; last apply ltn_trans with (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 478)
subgoal 1 (ID 478) is:
true = interference j t
subgoal 2 (ID 474) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 478)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
NEQT : t1 <= t < t2
============================
true = interference j t
----------------------------------------------------------------------------- *)
move: (H_work_conserving j t1 t2 t H_j_arrives H_job_of_tsk H_job_cost_positive H_busy_interval NEQT) ⇒ [Hn _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 561)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
NEQT : t1 <= t < t2
Hn : ~ interference j t -> scheduled_at sched j t
============================
true = interference j t
----------------------------------------------------------------------------- *)
apply/eqP;rewrite eq_sym eqb_id; apply/negPn/negP; intros CONTR; move: CONTR ⇒ /negP CONTR.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 752)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
NEQT : t1 <= t < t2
Hn : ~ interference j t -> scheduled_at sched j t
CONTR : ~ interference j t
============================
False
----------------------------------------------------------------------------- *)
apply Hn in CONTR; rewrite scheduled_at_def in CONTR; simpl in CONTR.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 839)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
NEQT : t1 <= t < t2
Hn : ~ interference j t -> scheduled_at sched j t
CONTR : sched t == Some j
============================
False
----------------------------------------------------------------------------- *)
by rewrite H_sched [Some j' == Some j](negbTE (option_inj_neq (neq_sym H_j_neq_j'))) in CONTR.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 474)
subgoal 1 (ID 474) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 474)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
rewrite big_mkcond; apply/sum_seq_gt0P; ∃ j'; split; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1004)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
0 < (if job_of_task tsk j' then Some j' == Some j' else 0)
subgoal 2 (ID 1003) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1004)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
0 < (if job_of_task tsk j' then Some j' == Some j' else 0)
----------------------------------------------------------------------------- *)
by move: H_not_job_of_tsk ⇒ /eqP TSK; rewrite /job_of_task TSK eq_refl eq_refl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1003)
subgoal 1 (ID 1003) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1003)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1003)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
intros. have ARR:= arrives_after_beginning_of_busy_interval j j' _ _ _ _ _ t1 t2 _ t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1073)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrives_in arr_seq j ->
arrives_in arr_seq j' ->
job_task j = tsk ->
job_task j' = tsk ->
job_cost_positive j ->
busy_interval j t1 t2 ->
t1 <= t -> pending sched j' t -> arrived_between j' t1 (succn t)
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
feed_n 8 ARR; try (done || by move: H_t_in_interval ⇒ /andP [T1 T2]).
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 1092)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : job_task j' = tsk ->
job_cost_positive j ->
busy_interval j t1 t2 ->
t1 <= t -> pending sched j' t -> arrived_between j' t1 (succn t)
============================
job_task j' = tsk
subgoal 2 (ID 1116) is:
pending sched j' t
subgoal 3 (ID 1121) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1092)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : job_task j' = tsk ->
job_cost_positive j ->
busy_interval j t1 t2 ->
t1 <= t -> pending sched j' t -> arrived_between j' t1 (succn t)
============================
job_task j' = tsk
----------------------------------------------------------------------------- *)
by move: H_not_job_of_tsk ⇒ /eqP TSK; rewrite TSK.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1116)
subgoal 1 (ID 1116) is:
pending sched j' t
subgoal 2 (ID 1121) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1116)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : pending sched j' t -> arrived_between j' t1 (succn t)
============================
pending sched j' t
subgoal 2 (ID 1121) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1116)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : pending sched j' t -> arrived_between j' t1 (succn t)
============================
pending sched j' t
----------------------------------------------------------------------------- *)
move: H_sched ⇒ /eqP SCHEDt.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1537)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : pending sched j' t -> arrived_between j' t1 (succn t)
SCHEDt : sched t == Some j'
============================
pending sched j' t
----------------------------------------------------------------------------- *)
apply scheduled_implies_pending;
auto using ideal_proc_model_ensures_ideal_progress.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1545)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : pending sched j' t -> arrived_between j' t1 (succn t)
SCHEDt : sched t == Some j'
============================
scheduled_at sched j' t
----------------------------------------------------------------------------- *)
by rewrite scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1121)
subgoal 1 (ID 1121) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1121)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
case_eq (job_arrival j' ≤ job_arrival j) ⇒ ARRNEQ.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1576)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = true
============================
j' \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 1577) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1576)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = true
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: ARR ⇒ /andP [РР _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1619)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARRNEQ : (job_arrival j' <= job_arrival j) = true
РР : t1 <= job_arrival j'
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1624)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARRNEQ : (job_arrival j' <= job_arrival j) = true
РР : t1 <= job_arrival j'
============================
arrived_between j' t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1 ltnS.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1577)
subgoal 1 (ID 1577) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1577)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = false
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1577)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = false
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
exfalso.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1697)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = false
============================
False
----------------------------------------------------------------------------- *)
apply negbT in ARRNEQ; rewrite -ltnNge in ARRNEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1779)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
============================
False
----------------------------------------------------------------------------- *)
move: (H_sequential_tasks j j' t) ⇒ CONTR.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1781)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : same_task j j' ->
job_arrival j < job_arrival j' ->
scheduled_at sched j' t -> completed_by sched j t
============================
False
----------------------------------------------------------------------------- *)
feed_n 3 CONTR; try done.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 1782)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : same_task j j' ->
job_arrival j < job_arrival j' ->
scheduled_at sched j' t -> completed_by sched j t
============================
same_task j j'
subgoal 2 (ID 1794) is:
scheduled_at sched j' t
subgoal 3 (ID 1799) is:
False
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1782)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : same_task j j' ->
job_arrival j < job_arrival j' ->
scheduled_at sched j' t -> completed_by sched j t
============================
same_task j j'
----------------------------------------------------------------------------- *)
by rewrite /same_task eq_sym H_job_of_tsk.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1794)
subgoal 1 (ID 1794) is:
scheduled_at sched j' t
subgoal 2 (ID 1799) is:
False
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1794)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : scheduled_at sched j' t -> completed_by sched j t
============================
scheduled_at sched j' t
subgoal 2 (ID 1799) is:
False
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1794)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : scheduled_at sched j' t -> completed_by sched j t
============================
scheduled_at sched j' t
----------------------------------------------------------------------------- *)
by move: H_sched ⇒ /eqP SCHEDt; rewrite scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1799)
subgoal 1 (ID 1799) is:
False
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1799)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : completed_by sched j t
============================
False
----------------------------------------------------------------------------- *)
move: H_job_j_is_not_completed ⇒ /negP T; apply: T.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1984)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : completed_by sched j t
============================
completed_by sched j (t1 + x)
----------------------------------------------------------------------------- *)
apply completion_monotonic with t; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1989)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : completed_by sched j t
============================
t <= t1 + x
----------------------------------------------------------------------------- *)
by apply ltnW; move: H_t_in_interval ⇒ /andP [_ NEQ].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case3.
Section Case4.
interference j t + scheduled_at sched j t ≤
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
move: (H_busy_interval) ⇒ [[/andP [BUS LT] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 358)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
rewrite /cumul_task_interference /definitions.cumul_interference
/Sequential_Abstract_RTA.cumul_task_interference /task_interference_received_before
/task_scheduled_at /task_schedule.task_scheduled_at /service_of_jobs_at
/service_of_jobs.service_of_jobs_at scheduled_at_def/=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 394)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
have ARRs: arrives_in arr_seq j'; first by apply H_jobs_come_from_arrival_sequence with t; rewrite scheduled_at_def; apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 398)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0) +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite H_sched H_not_job_of_tsk addn0; simpl;
rewrite [Some j' == Some j](negbTE (option_inj_neq (neq_sym H_j_neq_j'))) addn0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 470)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
interference j t <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
replace (interference j t) with true; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 472)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
true = interference j t
subgoal 2 (ID 474) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 472)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
true = interference j t
----------------------------------------------------------------------------- *)
have NEQT: t1 ≤ t < t2.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 476)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
t1 <= t < t2
subgoal 2 (ID 478) is:
true = interference j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 476)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
t1 <= t < t2
----------------------------------------------------------------------------- *)
by move: H_t_in_interval ⇒ /andP [NEQ1 NEQ2]; apply/andP; split; last apply ltn_trans with (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 478)
subgoal 1 (ID 478) is:
true = interference j t
subgoal 2 (ID 474) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 478)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
NEQT : t1 <= t < t2
============================
true = interference j t
----------------------------------------------------------------------------- *)
move: (H_work_conserving j t1 t2 t H_j_arrives H_job_of_tsk H_job_cost_positive H_busy_interval NEQT) ⇒ [Hn _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 561)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
NEQT : t1 <= t < t2
Hn : ~ interference j t -> scheduled_at sched j t
============================
true = interference j t
----------------------------------------------------------------------------- *)
apply/eqP;rewrite eq_sym eqb_id; apply/negPn/negP; intros CONTR; move: CONTR ⇒ /negP CONTR.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 752)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
NEQT : t1 <= t < t2
Hn : ~ interference j t -> scheduled_at sched j t
CONTR : ~ interference j t
============================
False
----------------------------------------------------------------------------- *)
apply Hn in CONTR; rewrite scheduled_at_def in CONTR; simpl in CONTR.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 839)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
NEQT : t1 <= t < t2
Hn : ~ interference j t -> scheduled_at sched j t
CONTR : sched t == Some j
============================
False
----------------------------------------------------------------------------- *)
by rewrite H_sched [Some j' == Some j](negbTE (option_inj_neq (neq_sym H_j_neq_j'))) in CONTR.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 474)
subgoal 1 (ID 474) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 474)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
rewrite big_mkcond; apply/sum_seq_gt0P; ∃ j'; split; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1004)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
0 < (if job_of_task tsk j' then Some j' == Some j' else 0)
subgoal 2 (ID 1003) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1004)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
0 < (if job_of_task tsk j' then Some j' == Some j' else 0)
----------------------------------------------------------------------------- *)
by move: H_not_job_of_tsk ⇒ /eqP TSK; rewrite /job_of_task TSK eq_refl eq_refl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1003)
subgoal 1 (ID 1003) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1003)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1003)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
intros. have ARR:= arrives_after_beginning_of_busy_interval j j' _ _ _ _ _ t1 t2 _ t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1073)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrives_in arr_seq j ->
arrives_in arr_seq j' ->
job_task j = tsk ->
job_task j' = tsk ->
job_cost_positive j ->
busy_interval j t1 t2 ->
t1 <= t -> pending sched j' t -> arrived_between j' t1 (succn t)
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
feed_n 8 ARR; try (done || by move: H_t_in_interval ⇒ /andP [T1 T2]).
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 1092)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : job_task j' = tsk ->
job_cost_positive j ->
busy_interval j t1 t2 ->
t1 <= t -> pending sched j' t -> arrived_between j' t1 (succn t)
============================
job_task j' = tsk
subgoal 2 (ID 1116) is:
pending sched j' t
subgoal 3 (ID 1121) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1092)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : job_task j' = tsk ->
job_cost_positive j ->
busy_interval j t1 t2 ->
t1 <= t -> pending sched j' t -> arrived_between j' t1 (succn t)
============================
job_task j' = tsk
----------------------------------------------------------------------------- *)
by move: H_not_job_of_tsk ⇒ /eqP TSK; rewrite TSK.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1116)
subgoal 1 (ID 1116) is:
pending sched j' t
subgoal 2 (ID 1121) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1116)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : pending sched j' t -> arrived_between j' t1 (succn t)
============================
pending sched j' t
subgoal 2 (ID 1121) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1116)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : pending sched j' t -> arrived_between j' t1 (succn t)
============================
pending sched j' t
----------------------------------------------------------------------------- *)
move: H_sched ⇒ /eqP SCHEDt.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1537)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : pending sched j' t -> arrived_between j' t1 (succn t)
SCHEDt : sched t == Some j'
============================
pending sched j' t
----------------------------------------------------------------------------- *)
apply scheduled_implies_pending;
auto using ideal_proc_model_ensures_ideal_progress.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1545)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : pending sched j' t -> arrived_between j' t1 (succn t)
SCHEDt : sched t == Some j'
============================
scheduled_at sched j' t
----------------------------------------------------------------------------- *)
by rewrite scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1121)
subgoal 1 (ID 1121) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1121)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
case_eq (job_arrival j' ≤ job_arrival j) ⇒ ARRNEQ.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1576)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = true
============================
j' \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 1577) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1576)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = true
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: ARR ⇒ /andP [РР _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1619)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARRNEQ : (job_arrival j' <= job_arrival j) = true
РР : t1 <= job_arrival j'
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1624)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARRNEQ : (job_arrival j' <= job_arrival j) = true
РР : t1 <= job_arrival j'
============================
arrived_between j' t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1 ltnS.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1577)
subgoal 1 (ID 1577) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1577)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = false
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1577)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = false
============================
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
exfalso.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1697)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : (job_arrival j' <= job_arrival j) = false
============================
False
----------------------------------------------------------------------------- *)
apply negbT in ARRNEQ; rewrite -ltnNge in ARRNEQ.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1779)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
============================
False
----------------------------------------------------------------------------- *)
move: (H_sequential_tasks j j' t) ⇒ CONTR.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1781)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : same_task j j' ->
job_arrival j < job_arrival j' ->
scheduled_at sched j' t -> completed_by sched j t
============================
False
----------------------------------------------------------------------------- *)
feed_n 3 CONTR; try done.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 1782)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : same_task j j' ->
job_arrival j < job_arrival j' ->
scheduled_at sched j' t -> completed_by sched j t
============================
same_task j j'
subgoal 2 (ID 1794) is:
scheduled_at sched j' t
subgoal 3 (ID 1799) is:
False
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1782)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : same_task j j' ->
job_arrival j < job_arrival j' ->
scheduled_at sched j' t -> completed_by sched j t
============================
same_task j j'
----------------------------------------------------------------------------- *)
by rewrite /same_task eq_sym H_job_of_tsk.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1794)
subgoal 1 (ID 1794) is:
scheduled_at sched j' t
subgoal 2 (ID 1799) is:
False
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1794)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : scheduled_at sched j' t -> completed_by sched j t
============================
scheduled_at sched j' t
subgoal 2 (ID 1799) is:
False
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1794)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : scheduled_at sched j' t -> completed_by sched j t
============================
scheduled_at sched j' t
----------------------------------------------------------------------------- *)
by move: H_sched ⇒ /eqP SCHEDt; rewrite scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1799)
subgoal 1 (ID 1799) is:
False
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1799)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : completed_by sched j t
============================
False
----------------------------------------------------------------------------- *)
move: H_job_j_is_not_completed ⇒ /negP T; apply: T.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1984)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : completed_by sched j t
============================
completed_by sched j (t1 + x)
----------------------------------------------------------------------------- *)
apply completion_monotonic with t; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1989)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
j' : Job
H_sched : sched t = Some j'
H_not_job_of_tsk : job_task j' == tsk
H_j_neq_j' : j != j'
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
ARRs : arrives_in arr_seq j'
ARR : arrived_between j' t1 (succn t)
ARRNEQ : job_arrival j < job_arrival j'
CONTR : completed_by sched j t
============================
t <= t1 + x
----------------------------------------------------------------------------- *)
by apply ltnW; move: H_t_in_interval ⇒ /andP [_ NEQ].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case3.
Section Case4.
Assume that job j is scheduled at time t.
If job j is scheduled at time t, then [interference = 0, scheduled_at = 1], but
note that [service_of_jobs of tsk = 1], therefore inequality reduces to [1 ≤ 1].
Lemma interference_plus_sched_le_serv_of_task_plus_task_interference_j:
interference j t + scheduled_at sched j t ≤
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 292)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
============================
j \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 299) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
============================
j \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 304)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [GE _] [_ _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 384)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
GE : t1 <= job_arrival j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
subgoal 1 (ID 299) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
intros.
rewrite /cumul_task_interference /definitions.cumul_interference
/Sequential_Abstract_RTA.cumul_task_interference /task_interference_received_before
/task_scheduled_at /task_schedule.task_scheduled_at /service_of_jobs_at
/service_of_jobs.service_of_jobs_at scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 478)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
service_at sched j0 t +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite H_sched H_job_of_tsk neq_antirefl addn0; simpl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 495)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
move: (H_work_conserving j _ _ t H_j_arrives H_job_of_tsk H_job_cost_positive H_busy_interval) ⇒ WORK.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 501)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : t1 <= t < t2 -> ~ interference j t <-> scheduled_at sched j t
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
feed WORK.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 502)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : t1 <= t < t2 -> ~ interference j t <-> scheduled_at sched j t
============================
t1 <= t < t2
subgoal 2 (ID 507) is:
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 502)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : t1 <= t < t2 -> ~ interference j t <-> scheduled_at sched j t
============================
t1 <= t < t2
----------------------------------------------------------------------------- *)
move: H_t_in_interval ⇒ /andP [NEQ1 NEQ2].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 548)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : t1 <= t < t2 -> ~ interference j t <-> scheduled_at sched j t
NEQ1 : t1 <= t
NEQ2 : t < t1 + x
============================
t1 <= t < t2
----------------------------------------------------------------------------- *)
by apply/andP; split; last apply ltn_trans with (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 507)
subgoal 1 (ID 507) is:
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 507)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : ~ interference j t <-> scheduled_at sched j t
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
move: WORK ⇒ [_ ZIJT].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 591)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
ZIJT : scheduled_at sched j t -> ~ interference j t
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
feed ZIJT; first by rewrite scheduled_at_def H_sched; simpl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 597)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
ZIJT : ~ interference j t
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
move: ZIJT ⇒ /negP /eqP; rewrite eqb_negLR; simpl; move ⇒ /eqP ZIJT; rewrite ZIJT; simpl; rewrite add0n.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 754)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
ZIJT : interference j t = false
============================
(Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
rewrite !eq_refl; simpl; rewrite big_mkcond //=; apply/sum_seq_gt0P.
(* ----------------------------------[ coqtop ]---------------------------------
1 focused subgoal
(shelved: 1) (ID 819)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
ZIJT : interference j t = false
============================
exists i : Job,
i \in arrivals_between t1 (t1 + A + ε) /\
0 < (if job_of_task tsk i then sched t == Some i else 0)
----------------------------------------------------------------------------- *)
by ∃ j; split; [apply j_is_in_arrivals_between | rewrite /job_of_task H_job_of_tsk H_sched !eq_refl].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case4.
interference j t + scheduled_at sched j t ≤
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 292)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
============================
j \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 299) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
============================
j \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 304)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [GE _] [_ _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 384)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
GE : t1 <= job_arrival j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
subgoal 1 (ID 299) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
intros.
rewrite /cumul_task_interference /definitions.cumul_interference
/Sequential_Abstract_RTA.cumul_task_interference /task_interference_received_before
/task_scheduled_at /task_schedule.task_scheduled_at /service_of_jobs_at
/service_of_jobs.service_of_jobs_at scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 478)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
interference j t + (sched t == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
service_at sched j0 t +
~~ match sched t with
| Some j0 => job_task j0 == tsk
| None => false
end && has (interference^~ t) (task_arrivals_before arr_seq tsk t2)
----------------------------------------------------------------------------- *)
rewrite H_sched H_job_of_tsk neq_antirefl addn0; simpl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 495)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
move: (H_work_conserving j _ _ t H_j_arrives H_job_of_tsk H_job_cost_positive H_busy_interval) ⇒ WORK.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 501)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : t1 <= t < t2 -> ~ interference j t <-> scheduled_at sched j t
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
feed WORK.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 502)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : t1 <= t < t2 -> ~ interference j t <-> scheduled_at sched j t
============================
t1 <= t < t2
subgoal 2 (ID 507) is:
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 502)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : t1 <= t < t2 -> ~ interference j t <-> scheduled_at sched j t
============================
t1 <= t < t2
----------------------------------------------------------------------------- *)
move: H_t_in_interval ⇒ /andP [NEQ1 NEQ2].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 548)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : t1 <= t < t2 -> ~ interference j t <-> scheduled_at sched j t
NEQ1 : t1 <= t
NEQ2 : t < t1 + x
============================
t1 <= t < t2
----------------------------------------------------------------------------- *)
by apply/andP; split; last apply ltn_trans with (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 507)
subgoal 1 (ID 507) is:
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 507)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
WORK : ~ interference j t <-> scheduled_at sched j t
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
move: WORK ⇒ [_ ZIJT].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 591)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
ZIJT : scheduled_at sched j t -> ~ interference j t
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
feed ZIJT; first by rewrite scheduled_at_def H_sched; simpl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 597)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
ZIJT : ~ interference j t
============================
interference j t + (Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
move: ZIJT ⇒ /negP /eqP; rewrite eqb_negLR; simpl; move ⇒ /eqP ZIJT; rewrite ZIJT; simpl; rewrite add0n.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 754)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
ZIJT : interference j t = false
============================
(Some j == Some j) <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(sched t == Some j0)
----------------------------------------------------------------------------- *)
rewrite !eq_refl; simpl; rewrite big_mkcond //=; apply/sum_seq_gt0P.
(* ----------------------------------[ coqtop ]---------------------------------
1 focused subgoal
(shelved: 1) (ID 819)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
H_sched : sched t = Some j
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
ZIJT : interference j t = false
============================
exists i : Job,
i \in arrivals_between t1 (t1 + A + ε) /\
0 < (if job_of_task tsk i then sched t == Some i else 0)
----------------------------------------------------------------------------- *)
by ∃ j; split; [apply j_is_in_arrivals_between | rewrite /job_of_task H_job_of_tsk H_sched !eq_refl].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End Case4.
We use the above case analysis to prove that any time instant
t ∈ [t1, t1 + x) the sum of [interference j t] and [scheduled_at j t]
is no larger than the sum of [the service received by jobs of task
tsk at time t] and [task_iterference tsk t].
Lemma interference_plus_sched_le_serv_of_task_plus_task_interference:
interference j t + scheduled_at sched j t
≤ service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t
+ task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 289)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
move: (H_busy_interval) ⇒ [[/andP [BUS LT] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
case SCHEDt: (sched t) ⇒ [j1 | ].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 425)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
subgoal 2 (ID 489) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
2: by apply interference_plus_sched_le_serv_of_task_plus_task_interference_idle.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 425)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
have ARRs: arrives_in arr_seq j1;
first by apply H_jobs_come_from_arrival_sequence with t; rewrite scheduled_at_def; apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 494)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
ARRs : arrives_in arr_seq j1
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
case_eq (job_task j1 == tsk) ⇒ TSK.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 541)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
ARRs : arrives_in arr_seq j1
TSK : (job_task j1 == tsk) = true
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
subgoal 2 (ID 542) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
2: by eapply interference_plus_sched_le_serv_of_task_plus_task_interference_task; [eassumption| apply/negbT].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 541)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
ARRs : arrives_in arr_seq j1
TSK : (job_task j1 == tsk) = true
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
case EQ: (j == j1); [move: EQ ⇒ /eqP EQ; subst j1 | ].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 822)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
TSK : (job_task j == tsk) = true
ARRs : arrives_in arr_seq j
SCHEDt : sched t = Some j
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
subgoal 2 (ID 776) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
1: by apply interference_plus_sched_le_serv_of_task_plus_task_interference_j.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 776)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
ARRs : arrives_in arr_seq j1
TSK : (job_task j1 == tsk) = true
EQ : (j == j1) = false
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
eapply interference_plus_sched_le_serv_of_task_plus_task_interference_job;
auto; repeat split; eauto; apply/eqP; move: EQ ⇒ /eqP EQ; auto.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End CaseAnalysis.
interference j t + scheduled_at sched j t
≤ service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t
+ task_interference_received_before tsk t2 t.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 289)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
Proof.
move: (H_busy_interval) ⇒ [[/andP [BUS LT] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
case SCHEDt: (sched t) ⇒ [j1 | ].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 425)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
subgoal 2 (ID 489) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
2: by apply interference_plus_sched_le_serv_of_task_plus_task_interference_idle.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 425)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
have ARRs: arrives_in arr_seq j1;
first by apply H_jobs_come_from_arrival_sequence with t; rewrite scheduled_at_def; apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 494)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
ARRs : arrives_in arr_seq j1
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
case_eq (job_task j1 == tsk) ⇒ TSK.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 541)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
ARRs : arrives_in arr_seq j1
TSK : (job_task j1 == tsk) = true
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
subgoal 2 (ID 542) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
2: by eapply interference_plus_sched_le_serv_of_task_plus_task_interference_task; [eassumption| apply/negbT].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 541)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
ARRs : arrives_in arr_seq j1
TSK : (job_task j1 == tsk) = true
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
case EQ: (j == j1); [move: EQ ⇒ /eqP EQ; subst j1 | ].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 822)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
TSK : (job_task j == tsk) = true
ARRs : arrives_in arr_seq j
SCHEDt : sched t = Some j
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
subgoal 2 (ID 776) is:
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
1: by apply interference_plus_sched_le_serv_of_task_plus_task_interference_j.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 776)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
t : instant
H_t_in_interval : t1 <= t < t1 + x
BUS : t1 <= job_arrival j
LT : job_arrival j < t2
j1 : Job
SCHEDt : sched t = Some j1
ARRs : arrives_in arr_seq j1
TSK : (job_task j1 == tsk) = true
EQ : (j == j1) = false
============================
interference j t + scheduled_at sched j t <=
service_of_jobs_at (job_of_task tsk) (arrivals_between t1 (t1 + A + ε)) t +
task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
eapply interference_plus_sched_le_serv_of_task_plus_task_interference_job;
auto; repeat split; eauto; apply/eqP; move: EQ ⇒ /eqP EQ; auto.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End CaseAnalysis.
Next we prove cumulative version of the lemma above.
Lemma cumul_interference_plus_sched_le_serv_of_task_plus_cumul_task_interference:
cumul_interference j t1 (t1 + x)
≤ (task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x)) + cumul_task_interference t2 t1 (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 286)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
cumul_interference j t1 (t1 + x) <=
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
Proof.
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 291)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
j \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 293) is:
cumul_interference j t1 (t1 + x) <=
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 291)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
j \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 298)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [GE _] [_ _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 378)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
GE : t1 <= job_arrival j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 293)
subgoal 1 (ID 293) is:
cumul_interference j t1 (t1 + x) <=
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 293)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
cumul_interference j t1 (t1 + x) <=
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
rewrite /cumul_interference /cumul_interference /task_service_of_jobs_in
/service_of_jobs.task_service_of_jobs_in
/service_of_jobs exchange_big //=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 471)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
definitions.cumul_interference interference j t1 (t1 + x) <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
rewrite -(leq_add2r (\sum_(t1 ≤ t < (t1 + x)) service_at sched j t)).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 511)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
definitions.cumul_interference interference j t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t
----------------------------------------------------------------------------- *)
rewrite [X in _ ≤ X]addnC addnA subnKC; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 535)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i)
subgoal 2 (ID 534) is:
definitions.cumul_interference interference j t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 535)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i)
----------------------------------------------------------------------------- *)
rewrite exchange_big //= (big_rem j) //=; auto using j_is_in_arrivals_between.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 587)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(t1 <= t < t1 + x) (sched t == Some j) <=
(if job_of_task tsk j
then \sum_(t1 <= i < t1 + x) (sched i == Some j)
else 0) +
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_of_task tsk y) \sum_(t1 <= i < t1 + x) (sched i == Some y)
----------------------------------------------------------------------------- *)
by rewrite /job_of_task H_job_of_tsk eq_refl leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 534)
subgoal 1 (ID 534) is:
definitions.cumul_interference interference j t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 534)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
definitions.cumul_interference interference j t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
rewrite -big_split -big_split //=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 680)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(t1 <= i < t1 + x) (interference j i + (sched i == Some j)) <=
\sum_(t1 <= i < t1 + x)
(\sum_(i0 <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i0) (sched i == Some i0) +
task_interference_received_before tsk t2 i)
----------------------------------------------------------------------------- *)
rewrite big_nat_cond [X in _ ≤ X]big_nat_cond leq_sum //; move ⇒ t /andP [NEQ _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 801)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
t : nat
NEQ : t1 <= t < t1 + x
============================
interference j t + (sched t == Some j) <=
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk i)
(sched t == Some i) + task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
rewrite -scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 808)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
t : nat
NEQ : t1 <= t < t1 + x
============================
interference j t + scheduled_at sched j t <=
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk i)
(sched t == Some i) + task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
by apply interference_plus_sched_le_serv_of_task_plus_task_interference.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
cumul_interference j t1 (t1 + x)
≤ (task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x)) + cumul_task_interference t2 t1 (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 286)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
cumul_interference j t1 (t1 + x) <=
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
Proof.
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 291)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
j \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 293) is:
cumul_interference j t1 (t1 + x) <=
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 291)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
j \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 298)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [GE _] [_ _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 378)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
GE : t1 <= job_arrival j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 293)
subgoal 1 (ID 293) is:
cumul_interference j t1 (t1 + x) <=
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 293)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
cumul_interference j t1 (t1 + x) <=
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
rewrite /cumul_interference /cumul_interference /task_service_of_jobs_in
/service_of_jobs.task_service_of_jobs_in
/service_of_jobs exchange_big //=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 471)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
definitions.cumul_interference interference j t1 (t1 + x) <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
rewrite -(leq_add2r (\sum_(t1 ≤ t < (t1 + x)) service_at sched j t)).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 511)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
definitions.cumul_interference interference j t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t
----------------------------------------------------------------------------- *)
rewrite [X in _ ≤ X]addnC addnA subnKC; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 535)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i)
subgoal 2 (ID 534) is:
definitions.cumul_interference interference j t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 535)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i)
----------------------------------------------------------------------------- *)
rewrite exchange_big //= (big_rem j) //=; auto using j_is_in_arrivals_between.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 587)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(t1 <= t < t1 + x) (sched t == Some j) <=
(if job_of_task tsk j
then \sum_(t1 <= i < t1 + x) (sched i == Some j)
else 0) +
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_of_task tsk y) \sum_(t1 <= i < t1 + x) (sched i == Some y)
----------------------------------------------------------------------------- *)
by rewrite /job_of_task H_job_of_tsk eq_refl leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 534)
subgoal 1 (ID 534) is:
definitions.cumul_interference interference j t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 534)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
definitions.cumul_interference interference j t1 (t1 + x) +
\sum_(t1 <= t < t1 + x) service_at sched j t <=
\sum_(t1 <= j0 < t1 + x)
\sum_(i <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i) (sched j0 == Some i) +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
rewrite -big_split -big_split //=.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 680)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(t1 <= i < t1 + x) (interference j i + (sched i == Some j)) <=
\sum_(t1 <= i < t1 + x)
(\sum_(i0 <- arrivals_between t1 (t1 + A + ε) |
job_of_task tsk i0) (sched i == Some i0) +
task_interference_received_before tsk t2 i)
----------------------------------------------------------------------------- *)
rewrite big_nat_cond [X in _ ≤ X]big_nat_cond leq_sum //; move ⇒ t /andP [NEQ _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 801)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
t : nat
NEQ : t1 <= t < t1 + x
============================
interference j t + (sched t == Some j) <=
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk i)
(sched t == Some i) + task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
rewrite -scheduled_at_def.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 808)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
t : nat
NEQ : t1 <= t < t1 + x
============================
interference j t + scheduled_at sched j t <=
\sum_(i <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk i)
(sched t == Some i) + task_interference_received_before tsk t2 t
----------------------------------------------------------------------------- *)
by apply interference_plus_sched_le_serv_of_task_plus_task_interference.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
On the other hand, the service terms in the inequality
above can be upper-bound by the workload terms.
Lemma serv_of_task_le_workload_of_task_plus:
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
≤ (task_workload_between t1 (t1 + A + ε) - job_cost j)
+ cumul_task_interference t2 t1 (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 292)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
Proof.
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
j \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 299) is:
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
j \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 304)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [GE _] [_ _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 384)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
GE : t1 <= job_arrival j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
subgoal 1 (ID 299) is:
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
rewrite leq_add2r.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 448)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j
----------------------------------------------------------------------------- *)
rewrite /task_workload /task_service_of_jobs_in
/service_of_jobs.task_service_of_jobs_in/service_of_jobs /workload_of_jobs /job_of_task.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 488)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_task j0 == tsk)
service_during sched j0 t1 (t1 + x) - service_during sched j t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j
----------------------------------------------------------------------------- *)
rewrite (big_rem j) ?[X in _ ≤ X - _](big_rem j) //=; auto using j_is_in_arrivals_between.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 561)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
(if job_task j == tsk then service_during sched j t1 (t1 + x) else 0) +
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) -
service_during sched j t1 (t1 + x) <=
(if job_of_task tsk j then job_cost j else 0) +
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_of_task tsk y) job_cost y - job_cost j
----------------------------------------------------------------------------- *)
rewrite /job_of_task H_job_of_tsk eq_refl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 651)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
service_during sched j t1 (t1 + x) +
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) -
service_during sched j t1 (t1 + x) <=
job_cost j +
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_task y == tsk) job_cost y - job_cost j
----------------------------------------------------------------------------- *)
rewrite addnC -addnBA; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 663)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) +
(service_during sched j t1 (t1 + x) - service_during sched j t1 (t1 + x)) <=
job_cost j +
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_task y == tsk) job_cost y - job_cost j
----------------------------------------------------------------------------- *)
rewrite [X in _ ≤ X - _]addnC -addnBA; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 684)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) +
(service_during sched j t1 (t1 + x) - service_during sched j t1 (t1 + x)) <=
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_task y == tsk) job_cost y + (job_cost j - job_cost j)
----------------------------------------------------------------------------- *)
rewrite !subnn !addn0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 708)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) <=
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_task y == tsk) job_cost y
----------------------------------------------------------------------------- *)
by apply service_of_jobs_le_workload; auto using ideal_proc_model_provides_unit_service.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x)
≤ (task_workload_between t1 (t1 + A + ε) - job_cost j)
+ cumul_task_interference t2 t1 (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 292)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
Proof.
have j_is_in_arrivals_between: j \in arrivals_between t1 (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
j \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 299) is:
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 297)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
j \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 304)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [GE _] [_ _]] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 384)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
GE : t1 <= job_arrival j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
subgoal 1 (ID 299) is:
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) + cumul_task_interference t2 t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
rewrite leq_add2r.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 448)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x) -
service_during sched j t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j
----------------------------------------------------------------------------- *)
rewrite /task_workload /task_service_of_jobs_in
/service_of_jobs.task_service_of_jobs_in/service_of_jobs /workload_of_jobs /job_of_task.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 488)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_task j0 == tsk)
service_during sched j0 t1 (t1 + x) - service_during sched j t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j
----------------------------------------------------------------------------- *)
rewrite (big_rem j) ?[X in _ ≤ X - _](big_rem j) //=; auto using j_is_in_arrivals_between.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 561)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
(if job_task j == tsk then service_during sched j t1 (t1 + x) else 0) +
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) -
service_during sched j t1 (t1 + x) <=
(if job_of_task tsk j then job_cost j else 0) +
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_of_task tsk y) job_cost y - job_cost j
----------------------------------------------------------------------------- *)
rewrite /job_of_task H_job_of_tsk eq_refl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 651)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
service_during sched j t1 (t1 + x) +
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) -
service_during sched j t1 (t1 + x) <=
job_cost j +
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_task y == tsk) job_cost y - job_cost j
----------------------------------------------------------------------------- *)
rewrite addnC -addnBA; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 663)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) +
(service_during sched j t1 (t1 + x) - service_during sched j t1 (t1 + x)) <=
job_cost j +
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_task y == tsk) job_cost y - job_cost j
----------------------------------------------------------------------------- *)
rewrite [X in _ ≤ X - _]addnC -addnBA; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 684)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) +
(service_during sched j t1 (t1 + x) - service_during sched j t1 (t1 + x)) <=
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_task y == tsk) job_cost y + (job_cost j - job_cost j)
----------------------------------------------------------------------------- *)
rewrite !subnn !addn0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 708)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
j_is_in_arrivals_between : j \in arrivals_between t1 (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_between t1 (t1 + A + ε)) |
job_task y == tsk) service_during sched y t1 (t1 + x) <=
\sum_(y <- rem (T:=Job) j
(arrival_sequence.arrivals_between arr_seq t1 (t1 + A + ε)) |
job_task y == tsk) job_cost y
----------------------------------------------------------------------------- *)
by apply service_of_jobs_le_workload; auto using ideal_proc_model_provides_unit_service.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
Finally, we show that the cumulative interference of job j in the interval [t1, t1 + x)
is bounded by the sum of the task workload in the interval [t1, t1 + A + ε) and
the cumulative interference of j's task in the interval [t1, t1 + x).
Lemma cumulative_job_interference_le_task_interference_bound:
cumul_interference j t1 (t1 + x)
≤ (task_workload_between t1 (t1 + A + ε) - job_cost j)
+ cumul_task_interference t2 t1 (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 295)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
cumul_interference j t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
Proof.
apply leq_trans with
(task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x)
+ cumul_task_interference t2 t1 (t1 + x));
[ apply cumul_interference_plus_sched_le_serv_of_task_plus_cumul_task_interference
| apply serv_of_task_le_workload_of_task_plus].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End TaskInterferenceBoundsInterference.
cumul_interference j t1 (t1 + x)
≤ (task_workload_between t1 (t1 + A + ε) - job_cost j)
+ cumul_task_interference t2 t1 (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 295)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
cumul_interference j t1 (t1 + x) <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
Proof.
apply leq_trans with
(task_service_of_jobs_in (arrivals_between t1 (t1 + A + ε)) t1 (t1 + x)
- service_during sched j t1 (t1 + x)
+ cumul_task_interference t2 t1 (t1 + x));
[ apply cumul_interference_plus_sched_le_serv_of_task_plus_cumul_task_interference
| apply serv_of_task_le_workload_of_task_plus].
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End TaskInterferenceBoundsInterference.
In order to obtain a more convenient bound of the cumulative interference, we need to
abandon the actual workload in favor of a bound which depends on task parameters only.
So, we show that actual workload of the task excluding workload of any job j is no
greater than bound of workload excluding the cost of job j's task.
Lemma task_rbf_excl_tsk_bounds_task_workload_excl_j:
task_workload_between t1 (t1 + A + ε) - job_cost j ≤ task_rbf (A + ε) - task_cost tsk.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 287)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
Proof.
move: H_j_arrives H_job_of_tsk H_busy_interval ⇒ ARR TSK [[/andP [JAGET1 JALTT2] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 352)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
apply leq_trans with
(task_cost tsk × number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) - task_cost tsk); last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk <= task_rbf (A + ε) - task_cost tsk
subgoal 2 (ID 360) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk <= task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
rewrite leq_sub2r // leq_mul2l; apply/orP; right.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 421)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) <=
max_arrivals tsk (A + ε)
----------------------------------------------------------------------------- *)
rewrite -addnA -{2}[(A+1)](addKn t1).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 434)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
number_of_task_arrivals arr_seq tsk t1 (t1 + (A + ε)) <=
max_arrivals tsk (t1 + (A + 1) - t1)
----------------------------------------------------------------------------- *)
by apply H_is_arrival_curve; auto using leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 360)
subgoal 1 (ID 360) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 360)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
have Fact6: j \in arrivals_between (t1 + A) (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 441)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
j \in arrivals_between (t1 + A) (t1 + A + ε)
subgoal 2 (ID 443) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 441)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
j \in arrivals_between (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
apply arrived_between_implies_in_arrivals; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 448)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
arrived_between j (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
apply/andP; split; rewrite /A subnKC //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 510)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
job_arrival j < job_arrival j + ε
----------------------------------------------------------------------------- *)
by rewrite addn1 ltnSn //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 443)
subgoal 1 (ID 443) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 443)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
have Fact4: j \in arrivals_at arr_seq (t1 + A).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 545)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
============================
j \in arrivals_at arr_seq (t1 + A)
subgoal 2 (ID 547) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 545)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
============================
j \in arrivals_at arr_seq (t1 + A)
----------------------------------------------------------------------------- *)
by move: ARR ⇒ [t ARR]; rewrite subnKC //; feed (H_arrival_times_are_consistent j t); try (subst t).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 547)
subgoal 1 (ID 547) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 547)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
have Fact1: 1 ≤ number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 604)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
============================
0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 2 (ID 606) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 604)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
============================
0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
rewrite /number_of_task_arrivals /task_arrivals_between /arrival_sequence.arrivals_between.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 623)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
============================
0 <
size
[seq j0 <- \big[cat/[::]]_(t1 + A <= t < t1 + A + ε)
arrivals_at arr_seq t
| job_task j0 == tsk]
----------------------------------------------------------------------------- *)
by rewrite -count_filter_fun -has_count; apply/hasP; ∃ j; last rewrite TSK.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 606)
subgoal 1 (ID 606) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 606)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite (@num_arrivals_of_task_cat _ _ _ _ _ (t1 + A)); last by apply/andP; split; rewrite leq_addr //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 691)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk *
(number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite mulnDr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 735)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
have Step1: task_workload_between t1 (t1 + A + ε)
= task_workload_between t1 (t1 + A) + task_workload_between (t1 + A) (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 738)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) =
task_workload_between t1 (t1 + A) +
task_workload_between (t1 + A) (t1 + A + ε)
subgoal 2 (ID 740) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 738)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) =
task_workload_between t1 (t1 + A) +
task_workload_between (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply workload_of_jobs_cat; apply/andP; split; rewrite leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 740)
subgoal 1 (ID 740) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 740)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
Step1 : task_workload_between t1 (t1 + A + ε) =
task_workload_between t1 (t1 + A) +
task_workload_between (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite Step1; clear Step1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 781)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A) +
task_workload_between (t1 + A) (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite -!addnBA; first last.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 788)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
job_cost j <= task_workload_between (t1 + A) (t1 + A + ε)
subgoal 2 (ID 795) is:
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 3 (ID 794) is:
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 788)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
job_cost j <= task_workload_between (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
by rewrite /task_workload_between /workload.task_workload_between /task_workload
/workload_of_jobs /job_of_task (big_rem j) //= TSK eq_refl leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 795)
subgoal 1 (ID 795) is:
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 2 (ID 794) is:
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 795)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 2 (ID 794) is:
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 795)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
apply leq_trans with (task_cost tsk); first by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 892)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
by rewrite -{1}[task_cost tsk]muln1 leq_mul2l; apply/orP; right.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 794)
subgoal 1 (ID 794) is:
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 794)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
rewrite leq_add; [by done | by eapply task_workload_le_num_of_arrivals_times_cost; eauto | ].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 940)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between (t1 + A) (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite /task_workload_between /workload.task_workload_between /task_workload /workload_of_jobs
/arrival_sequence.arrivals_between /number_of_task_arrivals /task_arrivals_between
/arrival_sequence.arrivals_between /job_of_task.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1000)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(j0 <- \big[cat/[::]]_(t1 + A <= t < t1 + A + ε) arrivals_at arr_seq t |
job_task j0 == tsk) job_cost j0 - job_cost j <=
task_cost tsk *
size
[seq j0 <- \big[cat/[::]]_(t1 + A <= t < t1 + A + ε)
arrivals_at arr_seq t
| job_task j0 == tsk] - task_cost tsk
----------------------------------------------------------------------------- *)
rewrite {1}addn1 big_nat1 addn1 big_nat1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1022)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(j0 <- arrivals_at arr_seq (t1 + A) | job_task j0 == tsk) job_cost j0 -
job_cost j <=
task_cost tsk *
size [seq j0 <- arrivals_at arr_seq (t1 + A) | job_task j0 == tsk] -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite (big_rem j) //= TSK !eq_refl; simpl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1072)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
job_cost j +
\sum_(y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) |
job_task y == tsk) job_cost y - job_cost j <=
task_cost tsk *
size [seq j0 <- arrivals_at arr_seq (t1 + A) | job_task j0 == tsk] -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite addnC -addnBA // subnn addn0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1117)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) |
job_task y == tsk) job_cost y <=
task_cost tsk *
size [seq j0 <- arrivals_at arr_seq (t1 + A) | job_task j0 == tsk] -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite (filter_size_rem _ j); [ | by done | by rewrite TSK].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1127)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) |
job_task y == tsk) job_cost y <=
task_cost tsk *
(size
[seq y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A))
| job_task y == tsk] + 1) - task_cost tsk
----------------------------------------------------------------------------- *)
rewrite mulnDr mulnC muln1 -addnBA // subnn addn0 mulnC.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1195)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) |
job_task y == tsk) job_cost y <=
task_cost tsk *
size
[seq y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A))
| job_task y == tsk]
----------------------------------------------------------------------------- *)
apply sum_majorant_constant.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1196)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
forall a : Job,
a \in rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) ->
job_task a == tsk -> job_cost a <= task_cost tsk
----------------------------------------------------------------------------- *)
move ⇒ j' ARR' /eqP TSK2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1232)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
j' : Job
ARR' : j' \in rem (T:=Job) j (arrivals_at arr_seq (t1 + A))
TSK2 : job_task j' = tsk
============================
job_cost j' <= task_cost tsk
----------------------------------------------------------------------------- *)
by rewrite -TSK2; apply H_job_cost_le_task_cost; ∃ (t1 + A); apply rem_in in ARR'.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
task_workload_between t1 (t1 + A + ε) - job_cost j ≤ task_rbf (A + ε) - task_cost tsk.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 287)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
Proof.
move: H_j_arrives H_job_of_tsk H_busy_interval ⇒ ARR TSK [[/andP [JAGET1 JALTT2] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 352)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
apply leq_trans with
(task_cost tsk × number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) - task_cost tsk); last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk <= task_rbf (A + ε) - task_cost tsk
subgoal 2 (ID 360) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk <= task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
rewrite leq_sub2r // leq_mul2l; apply/orP; right.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 421)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) <=
max_arrivals tsk (A + ε)
----------------------------------------------------------------------------- *)
rewrite -addnA -{2}[(A+1)](addKn t1).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 434)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
number_of_task_arrivals arr_seq tsk t1 (t1 + (A + ε)) <=
max_arrivals tsk (t1 + (A + 1) - t1)
----------------------------------------------------------------------------- *)
by apply H_is_arrival_curve; auto using leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 360)
subgoal 1 (ID 360) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 360)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
have Fact6: j \in arrivals_between (t1 + A) (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 441)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
j \in arrivals_between (t1 + A) (t1 + A + ε)
subgoal 2 (ID 443) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 441)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
j \in arrivals_between (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
apply arrived_between_implies_in_arrivals; try done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 448)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
arrived_between j (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
apply/andP; split; rewrite /A subnKC //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 510)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
============================
job_arrival j < job_arrival j + ε
----------------------------------------------------------------------------- *)
by rewrite addn1 ltnSn //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 443)
subgoal 1 (ID 443) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 443)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
have Fact4: j \in arrivals_at arr_seq (t1 + A).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 545)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
============================
j \in arrivals_at arr_seq (t1 + A)
subgoal 2 (ID 547) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 545)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
============================
j \in arrivals_at arr_seq (t1 + A)
----------------------------------------------------------------------------- *)
by move: ARR ⇒ [t ARR]; rewrite subnKC //; feed (H_arrival_times_are_consistent j t); try (subst t).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 547)
subgoal 1 (ID 547) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 547)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
have Fact1: 1 ≤ number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 604)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
============================
0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 2 (ID 606) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 604)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
============================
0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
rewrite /number_of_task_arrivals /task_arrivals_between /arrival_sequence.arrivals_between.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 623)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
============================
0 <
size
[seq j0 <- \big[cat/[::]]_(t1 + A <= t < t1 + A + ε)
arrivals_at arr_seq t
| job_task j0 == tsk]
----------------------------------------------------------------------------- *)
by rewrite -count_filter_fun -has_count; apply/hasP; ∃ j; last rewrite TSK.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 606)
subgoal 1 (ID 606) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 606)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite (@num_arrivals_of_task_cat _ _ _ _ _ (t1 + A)); last by apply/andP; split; rewrite leq_addr //.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 691)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk *
(number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite mulnDr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 735)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
have Step1: task_workload_between t1 (t1 + A + ε)
= task_workload_between t1 (t1 + A) + task_workload_between (t1 + A) (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 738)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) =
task_workload_between t1 (t1 + A) +
task_workload_between (t1 + A) (t1 + A + ε)
subgoal 2 (ID 740) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 738)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) =
task_workload_between t1 (t1 + A) +
task_workload_between (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply workload_of_jobs_cat; apply/andP; split; rewrite leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 740)
subgoal 1 (ID 740) is:
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 740)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
Step1 : task_workload_between t1 (t1 + A + ε) =
task_workload_between t1 (t1 + A) +
task_workload_between (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite Step1; clear Step1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 781)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A) +
task_workload_between (t1 + A) (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite -!addnBA; first last.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 788)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
job_cost j <= task_workload_between (t1 + A) (t1 + A + ε)
subgoal 2 (ID 795) is:
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 3 (ID 794) is:
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 788)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
job_cost j <= task_workload_between (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
by rewrite /task_workload_between /workload.task_workload_between /task_workload
/workload_of_jobs /job_of_task (big_rem j) //= TSK eq_refl leq_addr.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 795)
subgoal 1 (ID 795) is:
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 2 (ID 794) is:
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 795)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 2 (ID 794) is:
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 795)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
apply leq_trans with (task_cost tsk); first by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 892)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
----------------------------------------------------------------------------- *)
by rewrite -{1}[task_cost tsk]muln1 leq_mul2l; apply/orP; right.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 794)
subgoal 1 (ID 794) is:
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 794)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between t1 (t1 + A) +
(task_workload_between (t1 + A) (t1 + A + ε) - job_cost j) <=
task_cost tsk * number_of_task_arrivals arr_seq tsk t1 (t1 + A) +
(task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk)
----------------------------------------------------------------------------- *)
rewrite leq_add; [by done | by eapply task_workload_le_num_of_arrivals_times_cost; eauto | ].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 940)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
task_workload_between (t1 + A) (t1 + A + ε) - job_cost j <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε) -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite /task_workload_between /workload.task_workload_between /task_workload /workload_of_jobs
/arrival_sequence.arrivals_between /number_of_task_arrivals /task_arrivals_between
/arrival_sequence.arrivals_between /job_of_task.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1000)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(j0 <- \big[cat/[::]]_(t1 + A <= t < t1 + A + ε) arrivals_at arr_seq t |
job_task j0 == tsk) job_cost j0 - job_cost j <=
task_cost tsk *
size
[seq j0 <- \big[cat/[::]]_(t1 + A <= t < t1 + A + ε)
arrivals_at arr_seq t
| job_task j0 == tsk] - task_cost tsk
----------------------------------------------------------------------------- *)
rewrite {1}addn1 big_nat1 addn1 big_nat1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1022)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(j0 <- arrivals_at arr_seq (t1 + A) | job_task j0 == tsk) job_cost j0 -
job_cost j <=
task_cost tsk *
size [seq j0 <- arrivals_at arr_seq (t1 + A) | job_task j0 == tsk] -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite (big_rem j) //= TSK !eq_refl; simpl.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1072)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
job_cost j +
\sum_(y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) |
job_task y == tsk) job_cost y - job_cost j <=
task_cost tsk *
size [seq j0 <- arrivals_at arr_seq (t1 + A) | job_task j0 == tsk] -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite addnC -addnBA // subnn addn0.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1117)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) |
job_task y == tsk) job_cost y <=
task_cost tsk *
size [seq j0 <- arrivals_at arr_seq (t1 + A) | job_task j0 == tsk] -
task_cost tsk
----------------------------------------------------------------------------- *)
rewrite (filter_size_rem _ j); [ | by done | by rewrite TSK].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1127)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) |
job_task y == tsk) job_cost y <=
task_cost tsk *
(size
[seq y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A))
| job_task y == tsk] + 1) - task_cost tsk
----------------------------------------------------------------------------- *)
rewrite mulnDr mulnC muln1 -addnBA // subnn addn0 mulnC.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1195)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
\sum_(y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) |
job_task y == tsk) job_cost y <=
task_cost tsk *
size
[seq y <- rem (T:=Job) j (arrivals_at arr_seq (t1 + A))
| job_task y == tsk]
----------------------------------------------------------------------------- *)
apply sum_majorant_constant.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1196)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
============================
forall a : Job,
a \in rem (T:=Job) j (arrivals_at arr_seq (t1 + A)) ->
job_task a == tsk -> job_cost a <= task_cost tsk
----------------------------------------------------------------------------- *)
move ⇒ j' ARR' /eqP TSK2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1232)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
JAGET1 : t1 <= job_arrival j
JALTT2 : job_arrival j < t2
Fact6 : j \in arrivals_between (t1 + A) (t1 + A + ε)
Fact4 : j \in arrivals_at arr_seq (t1 + A)
Fact1 : 0 < number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
j' : Job
ARR' : j' \in rem (T:=Job) j (arrivals_at arr_seq (t1 + A))
TSK2 : job_task j' = tsk
============================
job_cost j' <= task_cost tsk
----------------------------------------------------------------------------- *)
by rewrite -TSK2; apply H_job_cost_le_task_cost; ∃ (t1 + A); apply rem_in in ARR'.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
Finally, we use the lemmas above to obtain the bound on
interference in terms of task_rbf and task_interfere.
Lemma cumulative_job_interference_bound:
cumul_interference j t1 (t1 + x)
≤ (task_rbf (A + ε) - task_cost tsk) + cumul_task_interference t2 t1 (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 290)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
cumul_interference j t1 (t1 + x) <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
Proof.
set (y := t1 + x) in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 295)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
============================
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
have IN: j \in arrivals_between t1 (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
============================
j \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 302) is:
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
============================
j \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 307)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [GE _] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 377)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
GE : t1 <= job_arrival j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 302)
subgoal 1 (ID 302) is:
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 302)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
IN : j \in arrivals_between t1 (t1 + A + ε)
============================
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
apply leq_trans with (task_workload_between t1 (t1+A+ε) - job_cost j + cumul_task_interference t2 t1 y).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 439)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
IN : j \in arrivals_between t1 (t1 + A + ε)
============================
cumul_interference j t1 y <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 y
subgoal 2 (ID 440) is:
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
- by apply cumulative_job_interference_le_task_interference_bound.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 440)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
IN : j \in arrivals_between t1 (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
- rewrite leq_add2r.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 445)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
IN : j \in arrivals_between t1 (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
eapply task_rbf_excl_tsk_bounds_task_workload_excl_j; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End BoundOfCumulativeJobInterference.
cumul_interference j t1 (t1 + x)
≤ (task_rbf (A + ε) - task_cost tsk) + cumul_task_interference t2 t1 (t1 + x).
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 290)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
H_inside_busy_interval : t1 + x < t2
H_job_j_is_not_completed : ~~ completed_by sched j (t1 + x)
============================
cumul_interference j t1 (t1 + x) <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + x)
----------------------------------------------------------------------------- *)
Proof.
set (y := t1 + x) in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 295)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
============================
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
have IN: j \in arrivals_between t1 (t1 + A + ε).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
============================
j \in arrivals_between t1 (t1 + A + ε)
subgoal 2 (ID 302) is:
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
============================
j \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
eapply arrived_between_implies_in_arrivals; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 307)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
move: (H_busy_interval) ⇒ [[/andP [GE _] _] _].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 377)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
GE : t1 <= job_arrival j
============================
arrived_between j t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
by apply/andP; split; last rewrite /A subnKC // addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 302)
subgoal 1 (ID 302) is:
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 302)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
IN : j \in arrivals_between t1 (t1 + A + ε)
============================
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
apply leq_trans with (task_workload_between t1 (t1+A+ε) - job_cost j + cumul_task_interference t2 t1 y).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 439)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
IN : j \in arrivals_between t1 (t1 + A + ε)
============================
cumul_interference j t1 y <=
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 y
subgoal 2 (ID 440) is:
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
- by apply cumulative_job_interference_le_task_interference_bound.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 440)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
IN : j \in arrivals_between t1 (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j +
cumul_task_interference t2 t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
- rewrite leq_add2r.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 445)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival j - t1 : duration
x : duration
y := t1 + x : nat
H_inside_busy_interval : y < t2
H_job_j_is_not_completed : ~~ completed_by sched j y
IN : j \in arrivals_between t1 (t1 + A + ε)
============================
task_workload_between t1 (t1 + A + ε) - job_cost j <=
task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
eapply task_rbf_excl_tsk_bounds_task_workload_excl_j; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End BoundOfCumulativeJobInterference.
In this section, we prove that [H_R_is_maximum_seq] implies [H_R_is_maximum].
Consider any 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_j_arrives : arrives_in arr_seq j.
Hypothesis H_job_of_tsk : job_task j = tsk.
For simplicity, let's define a local name for the search space.
We prove that [H_R_is_maximum] holds.
Lemma max_in_seq_hypothesis_implies_max_in_nonseq_hypothesis:
∀ (A : duration),
is_in_search_space A →
∃ (F : duration),
A + F = task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A (A + F)) ∧
F + (task_cost tsk - task_run_to_completion_threshold tsk) ≤ R.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 288)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
============================
forall A : duration,
is_in_search_space A ->
exists F : duration,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
Proof.
move: H_valid_run_to_completion_threshold ⇒ [PRT1 PRT2].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
============================
forall A : duration,
is_in_search_space A ->
exists F : duration,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
intros A INSP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 302)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
============================
exists F : duration,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
clear H_sequential_tasks H_interference_and_workload_consistent_with_sequential_tasks.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 303)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
============================
exists F : duration,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
move: (H_R_is_maximum_seq _ INSP) ⇒ [F [FIX LE]].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 327)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
exists F0 : duration,
A + F0 =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F0)) /\
F0 + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
∃ F; split; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 331)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F))
----------------------------------------------------------------------------- *)
rewrite {1}FIX.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 334)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F))
----------------------------------------------------------------------------- *)
apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 focused subgoal
(shelved: 1) (ID 389)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) ==
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F))
----------------------------------------------------------------------------- *)
rewrite addnA eqn_add2r.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 401)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) ==
task_run_to_completion_threshold tsk + (task_rbf (A + ε) - task_cost tsk)
----------------------------------------------------------------------------- *)
rewrite addnBA; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_cost tsk <= task_rbf (A + ε)
subgoal 2 (ID 407) is:
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) ==
task_run_to_completion_threshold tsk + task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_cost tsk <= task_rbf (A + ε)
----------------------------------------------------------------------------- *)
apply leq_trans with (task_rbf 1).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 409)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_cost tsk <= task_rbf 1
subgoal 2 (ID 410) is:
task_rbf 1 <= task_rbf (A + ε)
----------------------------------------------------------------------------- *)
eapply task_rbf_1_ge_task_cost; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 410)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf 1 <= task_rbf (A + ε)
----------------------------------------------------------------------------- *)
eapply task_rbf_monotone; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 431)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
0 < A + ε
----------------------------------------------------------------------------- *)
by rewrite addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 407)
subgoal 1 (ID 407) is:
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) ==
task_run_to_completion_threshold tsk + task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 407)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) ==
task_run_to_completion_threshold tsk + task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
by rewrite subnBA; auto; rewrite addnC.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End MaxInSeqHypothesisImpMaxInNonseqHypothesis.
∀ (A : duration),
is_in_search_space A →
∃ (F : duration),
A + F = task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A (A + F)) ∧
F + (task_cost tsk - task_run_to_completion_threshold tsk) ≤ R.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 288)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
============================
forall A : duration,
is_in_search_space A ->
exists F : duration,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
Proof.
move: H_valid_run_to_completion_threshold ⇒ [PRT1 PRT2].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
============================
forall A : duration,
is_in_search_space A ->
exists F : duration,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
intros A INSP.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 302)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
============================
exists F : duration,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
clear H_sequential_tasks H_interference_and_workload_consistent_with_sequential_tasks.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 303)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
============================
exists F : duration,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
move: (H_R_is_maximum_seq _ INSP) ⇒ [F [FIX LE]].
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 327)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
exists F0 : duration,
A + F0 =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F0)) /\
F0 + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
∃ F; split; last by done.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 331)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F))
----------------------------------------------------------------------------- *)
rewrite {1}FIX.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 334)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F))
----------------------------------------------------------------------------- *)
apply/eqP.
(* ----------------------------------[ coqtop ]---------------------------------
1 focused subgoal
(shelved: 1) (ID 389)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) ==
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F))
----------------------------------------------------------------------------- *)
rewrite addnA eqn_add2r.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 401)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) ==
task_run_to_completion_threshold tsk + (task_rbf (A + ε) - task_cost tsk)
----------------------------------------------------------------------------- *)
rewrite addnBA; last first.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_cost tsk <= task_rbf (A + ε)
subgoal 2 (ID 407) is:
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) ==
task_run_to_completion_threshold tsk + task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_cost tsk <= task_rbf (A + ε)
----------------------------------------------------------------------------- *)
apply leq_trans with (task_rbf 1).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 409)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_cost tsk <= task_rbf 1
subgoal 2 (ID 410) is:
task_rbf 1 <= task_rbf (A + ε)
----------------------------------------------------------------------------- *)
eapply task_rbf_1_ge_task_cost; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 410)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf 1 <= task_rbf (A + ε)
----------------------------------------------------------------------------- *)
eapply task_rbf_monotone; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 431)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
0 < A + ε
----------------------------------------------------------------------------- *)
by rewrite addn1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 407)
subgoal 1 (ID 407) is:
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) ==
task_run_to_completion_threshold tsk + task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 407)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := reduction_of_search_space.is_in_search_space tsk
L total_interference_bound :
nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
is_in_search_space := [eta reduction_of_search_space.is_in_search_space tsk
L total_interference_bound] :
nat -> Prop
PRT1 : task_run_to_completion_threshold_le_task_cost tsk
PRT2 : task_run_to_completion_threshold_bounds_job_run_to_completion_threshold
arr_seq tsk
A : duration
INSP : is_in_search_space A
F : duration
FIX : A + F =
task_rbf (A + ε) -
(task_cost tsk - task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F)
LE : F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
============================
task_rbf (A + ε) - (task_cost tsk - task_run_to_completion_threshold tsk) ==
task_run_to_completion_threshold tsk + task_rbf (A + ε) - task_cost tsk
----------------------------------------------------------------------------- *)
by rewrite subnBA; auto; rewrite addnC.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End MaxInSeqHypothesisImpMaxInNonseqHypothesis.
Finally, we apply the [uniprocessor_response_time_bound] theorem, and using the
lemmas above, we prove that all the requirements are satisfied. So, R is a response
time bound.
Theorem uniprocessor_response_time_bound_seq:
response_time_bounded_by tsk R.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 269)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
============================
response_time_bounded_by tsk R
----------------------------------------------------------------------------- *)
Proof.
intros j ARR TSK.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 273)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
job_response_time_bound sched j R
----------------------------------------------------------------------------- *)
eapply uniprocessor_response_time_bound with
(interference_bound_function :=
fun tsk A R ⇒ task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A R)
(interfering_workload0 := interfering_workload); eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 299)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
job_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload
(fun (tsk0 : Task) (A : nat) (R0 : duration) =>
task_rbf (A + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A R0)
subgoal 2 (ID 300) is:
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
job_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload
(fun (tsk0 : Task) (A : nat) (R0 : duration) =>
task_rbf (A + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A R0)
----------------------------------------------------------------------------- *)
clear ARR TSK H_R_is_maximum_seq R j.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 312)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
============================
job_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload
(fun (tsk0 : Task) (A : nat) (R : duration) =>
task_rbf (A + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A R)
----------------------------------------------------------------------------- *)
intros t1 t2 R j BUSY NEQ ARR TSK COMPL.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 322)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
============================
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
move: (posnP (@job_cost _ H3 j)) ⇒ [ZERO|POS].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 339)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
ZERO : job_cost j = 0
============================
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
subgoal 2 (ID 340) is:
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 339)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
ZERO : job_cost j = 0
============================
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
exfalso.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 341)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
ZERO : job_cost j = 0
============================
False
----------------------------------------------------------------------------- *)
move: COMPL ⇒ /negP COMPL; apply: COMPL.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 375)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
ZERO : job_cost j = 0
============================
completed_by sched j (t1 + R)
----------------------------------------------------------------------------- *)
by rewrite /service.completed_by /completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 340)
subgoal 1 (ID 340) is:
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
subgoal 2 (ID 300) is:
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 340)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
POS : 0 < job_cost j
============================
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
set (A := job_arrival j - t1) in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 395)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
POS : 0 < job_cost j
A := job_arrival j - t1 : nat
============================
let offset := A in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
apply leq_trans with
(task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + R)).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 398)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
POS : 0 < job_cost j
A := job_arrival j - t1 : nat
============================
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + R)
subgoal 2 (ID 399) is:
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A R
----------------------------------------------------------------------------- *)
- by eapply cumulative_job_interference_bound; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 399)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
POS : 0 < job_cost j
A := job_arrival j - t1 : nat
============================
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A R
----------------------------------------------------------------------------- *)
- by rewrite leq_add2l; apply H_task_interference_is_bounded.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
subgoal 1 (ID 300) is:
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
by eapply max_in_seq_hypothesis_implies_max_in_nonseq_hypothesis; eauto.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End ResponseTimeBound.
End Sequential_Abstract_RTA.
response_time_bounded_by tsk R.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 269)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
============================
response_time_bounded_by tsk R
----------------------------------------------------------------------------- *)
Proof.
intros j ARR TSK.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 273)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
job_response_time_bound sched j R
----------------------------------------------------------------------------- *)
eapply uniprocessor_response_time_bound with
(interference_bound_function :=
fun tsk A R ⇒ task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A R)
(interfering_workload0 := interfering_workload); eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 299)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
job_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload
(fun (tsk0 : Task) (A : nat) (R0 : duration) =>
task_rbf (A + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A R0)
subgoal 2 (ID 300) is:
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 299)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
job_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload
(fun (tsk0 : Task) (A : nat) (R0 : duration) =>
task_rbf (A + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A R0)
----------------------------------------------------------------------------- *)
clear ARR TSK H_R_is_maximum_seq R j.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 312)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
============================
job_interference_is_bounded_by arr_seq sched tsk interference
interfering_workload
(fun (tsk0 : Task) (A : nat) (R : duration) =>
task_rbf (A + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A R)
----------------------------------------------------------------------------- *)
intros t1 t2 R j BUSY NEQ ARR TSK COMPL.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 322)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
============================
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
move: (posnP (@job_cost _ H3 j)) ⇒ [ZERO|POS].
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 339)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
ZERO : job_cost j = 0
============================
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
subgoal 2 (ID 340) is:
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 339)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
ZERO : job_cost j = 0
============================
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
exfalso.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 341)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
ZERO : job_cost j = 0
============================
False
----------------------------------------------------------------------------- *)
move: COMPL ⇒ /negP COMPL; apply: COMPL.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 375)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
ZERO : job_cost j = 0
============================
completed_by sched j (t1 + R)
----------------------------------------------------------------------------- *)
by rewrite /service.completed_by /completed_by ZERO.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 340)
subgoal 1 (ID 340) is:
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
subgoal 2 (ID 300) is:
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 340)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
POS : 0 < job_cost j
============================
let offset := job_arrival j - t1 in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
set (A := job_arrival j - t1) in ×.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 395)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
POS : 0 < job_cost j
A := job_arrival j - t1 : nat
============================
let offset := A in
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (offset + ε) - task_cost tsk +
task_interference_bound_function tsk offset R
----------------------------------------------------------------------------- *)
apply leq_trans with
(task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + R)).
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 398)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
POS : 0 < job_cost j
A := job_arrival j - t1 : nat
============================
definitions.cumul_interference interference j t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + R)
subgoal 2 (ID 399) is:
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A R
----------------------------------------------------------------------------- *)
- by eapply cumulative_job_interference_bound; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 399)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
t1, t2 : instant
R : nat
j : Job
BUSY : arrives_in arr_seq j
NEQ : job_task j = tsk
ARR : definitions.busy_interval sched interference interfering_workload j
t1 t2
TSK : t1 + R < t2
COMPL : ~~ completed_by sched j (t1 + R)
POS : 0 < job_cost j
A := job_arrival j - t1 : nat
============================
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 (t1 + R) <=
task_rbf (A + ε) - task_cost tsk + task_interference_bound_function tsk A R
----------------------------------------------------------------------------- *)
- by rewrite leq_add2l; apply H_task_interference_is_bounded.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
subgoal 1 (ID 300) is:
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 300)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_job_cost_le_task_cost : cost_of_jobs_from_arrival_sequence_le_task_cost
arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: (Job -> bool) -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
ARR : arrives_in arr_seq j
TSK : job_task j = tsk
============================
forall A : nat,
is_in_search_space tsk L
(fun (tsk0 : Task) (A0 : nat) (R0 : duration) =>
task_rbf (A0 + ε) - task_cost tsk0 +
task_interference_bound_function tsk0 A0 R0) A ->
exists F : nat,
A + F =
task_run_to_completion_threshold tsk +
(task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A (A + F)) /\
F + (task_cost tsk - task_run_to_completion_threshold tsk) <= R
----------------------------------------------------------------------------- *)
by eapply max_in_seq_hypothesis_implies_max_in_nonseq_hypothesis; eauto.
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
No more subgoals.
----------------------------------------------------------------------------- *)
Qed.
End ResponseTimeBound.
End Sequential_Abstract_RTA.