Library prosa.analysis.abstract.abstract_seq_rta
(* ----------------------------------[ coqtop ]---------------------------------
Welcome to Coq 8.11.2 (June 2020)
----------------------------------------------------------------------------- *)
Require Export prosa.analysis.definitions.task_schedule.
Require Export prosa.analysis.facts.model.rbf.
Require Export prosa.analysis.facts.model.task_arrivals.
Require Export prosa.analysis.facts.model.sequential.
Require Export prosa.analysis.abstract.abstract_rta.
Abstract Response-Time Analysis with sequential tasks
In this section we propose the general framework for response-time analysis (RTA) of uni-processor 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-necessary-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
interference 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 fix-point 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 1347)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1425)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1426) is:
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1425)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1426)
subgoal 1 (ID 1426) is:
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1426)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1444)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1466)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1347)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1425)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1426) is:
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1425)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1426)
subgoal 1 (ID 1426) is:
completed_by sched j2 t1
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1426)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1444)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1466)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1356)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1359)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1391)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1390) is:
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1391)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1390)
subgoal 1 (ID 1390) is:
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1390)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1463)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1534)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1539)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1544)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1356)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1359)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1391)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1390) is:
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1391)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1390)
subgoal 1 (ID 1390) is:
t1 <= job_arrival j2
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1390)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1463)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1534)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1539)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1544)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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_interference 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 1350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1411)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1447)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1450)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1468)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1541)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1611)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1641)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1411)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1447)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1450)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1468)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1541)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1611)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1641)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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_interference 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 1354)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1415)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1451)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1455)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1497)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1550)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1566)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1568) 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 1566)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1662)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1568)
subgoal 1 (ID 1568) 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 1568)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1699)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1775)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1848)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1878)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1354)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1415)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1451)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1455)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1497)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1550)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1566)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1568) 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 1566)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1662)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1568)
subgoal 1 (ID 1568) 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 1568)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1699)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1775)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1848)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1878)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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_interference 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1416)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1452)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1456)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1528)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1530)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1532) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1530)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1534)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1536) is:
true = interference j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1534)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1536)
subgoal 1 (ID 1536) is:
true = interference j t
subgoal 2 (ID 1532) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1536)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 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_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1810)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1897)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1532)
subgoal 1 (ID 1532) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1532)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2062)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2061) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2062)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2061)
subgoal 1 (ID 2061) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2061)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2061)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2131)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2150)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2174) is:
pending sched j' t
subgoal 3 (ID 2179) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2150)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2174)
subgoal 1 (ID 2174) is:
pending sched j' t
subgoal 2 (ID 2179) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2174)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2179) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2174)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2595)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2603)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2179)
subgoal 1 (ID 2179) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2179)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2634)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2635) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2634)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2677)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2682)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2635)
subgoal 1 (ID 2635) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2635)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2635)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2755)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2837)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2839)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2840)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2852) is:
scheduled_at sched j' t
subgoal 3 (ID 2857) is:
False
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2840)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2852)
subgoal 1 (ID 2852) is:
scheduled_at sched j' t
subgoal 2 (ID 2857) is:
False
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2852)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2857) is:
False
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2852)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2857)
subgoal 1 (ID 2857) is:
False
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2857)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 3042)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 3047)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1416)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1452)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1456)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1528)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1530)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1532) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1530)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1534)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1536) is:
true = interference j t
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1534)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1536)
subgoal 1 (ID 1536) is:
true = interference j t
subgoal 2 (ID 1532) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1536)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 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_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1810)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1897)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1532)
subgoal 1 (ID 1532) is:
true <=
\sum_(j0 <- arrivals_between t1 (t1 + A + ε) | job_of_task tsk j0)
(Some j' == Some j0)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1532)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2062)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2061) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2062)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2061)
subgoal 1 (ID 2061) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2061)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2061)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2131)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2150)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2174) is:
pending sched j' t
subgoal 3 (ID 2179) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2150)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2174)
subgoal 1 (ID 2174) is:
pending sched j' t
subgoal 2 (ID 2179) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2174)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2179) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2174)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2595)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2603)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2179)
subgoal 1 (ID 2179) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2179)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2634)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2635) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2634)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2677)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2682)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2635)
subgoal 1 (ID 2635) is:
j' \in arrivals_between t1 (t1 + A + ε)
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2635)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2635)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2755)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2837)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2839)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2840)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2852) is:
scheduled_at sched j' t
subgoal 3 (ID 2857) is:
False
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2840)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2852)
subgoal 1 (ID 2852) is:
scheduled_at sched j' t
subgoal 2 (ID 2857) is:
False
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 2852)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2857) is:
False
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2852)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2857)
subgoal 1 (ID 2857) is:
False
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2857)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 3042)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 3047)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1357) 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1362)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1442)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1357)
subgoal 1 (ID 1357) 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 1357)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1536)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1553)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1559)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1560)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1565) 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 1560)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1606)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1565)
subgoal 1 (ID 1565) 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 1565)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1649)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1655)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1812)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1877)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1357) 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1362)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1442)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1357)
subgoal 1 (ID 1357) 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 1357)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1536)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1553)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1559)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1560)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1565) 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 1560)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1606)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1565)
subgoal 1 (ID 1565) 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 1565)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1649)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1655)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1812)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1877)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1347)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1483)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1547) 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 1483)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1552)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1599)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1600) 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 1599)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1880)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1834) 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 1834)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1347)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1408)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1483)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1547) 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 1483)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1552)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1599)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1600) 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 1599)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1880)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1834) 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 1834)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1344)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1349)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1351) 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 1349)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1356)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1436)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1351)
subgoal 1 (ID 1351) 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 1351)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1529)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1569)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1593)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1592) 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 1593)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1645)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1592)
subgoal 1 (ID 1592) 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 1592)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1738)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1859)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1866)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1344)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1349)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1351) 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 1349)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1356)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1436)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1351)
subgoal 1 (ID 1351) 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 1351)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1529)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1569)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1593)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1592) 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 1593)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1645)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1592)
subgoal 1 (ID 1592) 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 1592)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1738)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1859)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1866)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1357) 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1362)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1442)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1357)
subgoal 1 (ID 1357) 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 1357)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1506)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1546)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 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_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1709)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1721)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1742)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1766)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1350)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1357) 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 1355)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1362)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1442)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1357)
subgoal 1 (ID 1357) 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 1357)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1506)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1546)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 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_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1709)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1721)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1742)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1766)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1353)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1353)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1345)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1410)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1419)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1418) 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 1419)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1479)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1492)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1418)
subgoal 1 (ID 1418) 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 1418)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1499)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1501) 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 1499)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1506)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1568)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1501)
subgoal 1 (ID 1501) 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 1501)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1603)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1605) 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 1603)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1605)
subgoal 1 (ID 1605) 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 1605)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1662)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1664) 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 1662)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1681)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 <- \cat_(t1 + A<=t<t1 + A + ε|true)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 1664)
subgoal 1 (ID 1664) 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 1664)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1749)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1793)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1796)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1798) 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 1796)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1798)
subgoal 1 (ID 1798) 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 1798)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1839)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1846)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1853) is:
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 3 (ID 1852) 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 1846)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1853)
subgoal 1 (ID 1853) is:
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 2 (ID 1852) 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 1853)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1852) 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 1853)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1950)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1852)
subgoal 1 (ID 1852) 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 1852)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1998)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2058)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 <- \cat_(t1 + A<=t<t1 + A + ε|true)arrivals_at arr_seq t |
job_task j0 == tsk) job_cost j0 - job_cost j <=
task_cost tsk *
size
[seq j0 <- \cat_(t1 + A<=t<t1 + A + ε|true)arrivals_at arr_seq t
| job_task j0 == tsk] - task_cost tsk
----------------------------------------------------------------------------- *)
rewrite {1}addn1 big_nat1 addn1 big_nat1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2080)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2130)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2175)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2185)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2253)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2254)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2290)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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_valid_job_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 1345)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1410)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1419)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1418) 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 1419)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1479)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1492)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1418)
subgoal 1 (ID 1418) 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 1418)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1499)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1501) 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 1499)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1506)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1568)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1501)
subgoal 1 (ID 1501) 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 1501)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1603)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1605) 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 1603)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1605)
subgoal 1 (ID 1605) 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 1605)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1662)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1664) 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 1662)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1681)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 <- \cat_(t1 + A<=t<t1 + A + ε|true)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 1664)
subgoal 1 (ID 1664) 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 1664)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1749)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1793)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1796)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1798) 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 1796)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1798)
subgoal 1 (ID 1798) 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 1798)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1839)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1846)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1853) is:
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 3 (ID 1852) 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 1846)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1853)
subgoal 1 (ID 1853) is:
task_cost tsk <=
task_cost tsk * number_of_task_arrivals arr_seq tsk (t1 + A) (t1 + A + ε)
subgoal 2 (ID 1852) 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 1853)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1852) 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 1853)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1950)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1852)
subgoal 1 (ID 1852) 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 1852)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1998)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2058)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 <- \cat_(t1 + A<=t<t1 + A + ε|true)arrivals_at arr_seq t |
job_task j0 == tsk) job_cost j0 - job_cost j <=
task_cost tsk *
size
[seq j0 <- \cat_(t1 + A<=t<t1 + A + ε|true)arrivals_at arr_seq t
| job_task j0 == tsk] - task_cost tsk
----------------------------------------------------------------------------- *)
rewrite {1}addn1 big_nat1 addn1 big_nat1.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 2080)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2130)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2175)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2185)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2253)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2254)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 2290)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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_valid_job_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_interference].
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 1348)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1353)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1358)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1360) is:
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1358)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1365)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1435)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1360)
subgoal 1 (ID 1360) is:
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1360)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1497)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1498) 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 1498)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1503)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1348)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_positive : job_cost_positive j
t1, t2 : instant
H_busy_interval : busy_interval j t1 t2
A := job_arrival 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 1353)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1358)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1360) is:
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
{
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1358)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1365)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1435)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1360)
subgoal 1 (ID 1360) is:
cumul_interference j t1 y <=
task_rbf (A + ε) - task_cost tsk + cumul_task_interference t2 t1 y
----------------------------------------------------------------------------- *)
}
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1360)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1497)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1498) 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 1498)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1503)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_completion_threshold tsk) +
task_interference_bound_function tsk A (A + F) /\
F +
(task_cost tsk -
task_run_to_completion_threshold tsk) <= R
j : Job
H_j_arrives : arrives_in arr_seq j
H_job_of_tsk : job_task j = tsk
H_job_cost_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 1346)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := 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 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 1358)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1360)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1385)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1389)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1392)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1447)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1459)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1466)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1465) 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 1466)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1467)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1468) is:
task_rbf 1 <= task_rbf (A + ε)
----------------------------------------------------------------------------- *)
eapply task_rbf_1_ge_task_cost; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1468)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1489)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1465)
subgoal 1 (ID 1465) 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 1465)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1346)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := 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 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 1358)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1360)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1385)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1389)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1392)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1447)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1459)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1466)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1465) 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 1466)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1467)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1468) is:
task_rbf 1 <= task_rbf (A + ε)
----------------------------------------------------------------------------- *)
eapply task_rbf_1_ge_task_cost; eauto 2.
(* ----------------------------------[ coqtop ]---------------------------------
1 subgoal (ID 1468)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1489)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1465)
subgoal 1 (ID 1465) 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 1465)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_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 := 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 search_space.is_in_search_space tsk L
total_interference_bound] :
nat -> Prop
PRT1 : task_rtc_bounded_by_cost tsk
PRT2 : job_respects_task_rtc 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 1327)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1331)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 ]---------------------------------
4 subgoals (ID 1352)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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
============================
ideal_progress_proc_model (processor_state Job)
subgoal 2 (ID 1353) is:
unit_service_proc_model (processor_state Job)
subgoal 3 (ID 1361) is:
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 4 (ID 1362) 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
----------------------------------------------------------------------------- *)
apply ideal_proc_model_ensures_ideal_progress.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 1353)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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
============================
unit_service_proc_model (processor_state Job)
subgoal 2 (ID 1361) is:
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 3 (ID 1362) 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
----------------------------------------------------------------------------- *)
apply ideal_proc_model_provides_unit_service.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 1362) 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 1361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 1376)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1386)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1403)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1404) 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 1403)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1405)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1439)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1404)
subgoal 1 (ID 1404) 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 1362) 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 1404)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1459)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1462)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1463) 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 1463)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1362)
subgoal 1 (ID 1362) 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 1362)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 1362)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 1327)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_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 1331)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 ]---------------------------------
4 subgoals (ID 1352)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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
============================
ideal_progress_proc_model (processor_state Job)
subgoal 2 (ID 1353) is:
unit_service_proc_model (processor_state Job)
subgoal 3 (ID 1361) is:
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 4 (ID 1362) 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
----------------------------------------------------------------------------- *)
apply ideal_proc_model_ensures_ideal_progress.
(* ----------------------------------[ coqtop ]---------------------------------
3 subgoals (ID 1353)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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
============================
unit_service_proc_model (processor_state Job)
subgoal 2 (ID 1361) is:
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 3 (ID 1362) 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
----------------------------------------------------------------------------- *)
apply ideal_proc_model_provides_unit_service.
(* ----------------------------------[ coqtop ]---------------------------------
2 subgoals (ID 1361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 1362) 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 1361)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 1376)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1386)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1403)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1404) 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 1403)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1405)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1439)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1404)
subgoal 1 (ID 1404) 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 1362) 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 1404)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1459)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1462)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1463) 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 1463)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_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 1362)
subgoal 1 (ID 1362) 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 1362)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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 1362)
Task : TaskType
H : TaskCost Task
H0 : TaskRunToCompletionThreshold Task
Job : JobType
H1 : JobTask Job Task
H2 : JobArrival Job
H3 : JobCost Job
H4 : JobPreemptable Job
arr_seq : arrival_sequence Job
H_arrival_times_are_consistent : consistent_arrival_times arr_seq
H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq
sched : schedule (processor_state Job)
H_jobs_come_from_arrival_sequence : jobs_come_from_arrival_sequence sched
arr_seq
H_jobs_must_arrive_to_execute : jobs_must_arrive_to_execute sched
H_completed_jobs_dont_execute : completed_jobs_dont_execute sched
H_valid_job_cost : arrivals_have_valid_job_costs arr_seq
ts : seq Task
tsk : Task
H_tsk_in_ts : tsk \in ts
H_valid_preemption_model : valid_preemption_model arr_seq sched
H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk
H5 : MaxArrivals Task
H_valid_arrival_curve : valid_taskset_arrival_curve ts max_arrivals
H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts
interference : Job -> instant -> bool
interfering_workload : Job -> instant -> duration
task_rbf := task_request_bound_function tsk : duration -> nat
busy_interval := definitions.busy_interval sched interference
interfering_workload : Job -> instant -> instant -> Prop
arrivals_between := arrival_sequence.arrivals_between arr_seq
: instant -> instant -> seq Job
service_of_jobs_at := service_of_jobs.service_of_jobs_at sched
: pred Job -> seq Job -> instant -> nat
task_workload_between := workload.task_workload_between arr_seq tsk
: instant -> instant -> nat
task_service_of_jobs_in := service_of_jobs.task_service_of_jobs_in sched
tsk : seq Job -> instant -> instant -> nat
response_time_bounded_by := task_response_time_bound arr_seq sched
: Task -> duration -> Prop
cumul_interference := definitions.cumul_interference interference
: Job -> nat -> nat -> nat
cumul_workload := cumul_interfering_workload interfering_workload
: Job -> nat -> nat -> nat
cumul_task_interference := Sequential_Abstract_RTA.cumul_task_interference
tsk : instant -> nat -> nat -> nat
H_work_conserving : work_conserving arr_seq sched tsk interference
interfering_workload
H_sequential_tasks : sequential_tasks sched
H_interference_and_workload_consistent_with_sequential_tasks : interference_and_workload_consistent_with_sequential_tasks
L : duration
H_busy_interval_exists : busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
task_interference_bound_function : Task -> duration -> duration -> duration
H_task_interference_is_bounded : task_interference_is_bounded_by
task_interference_bound_function
total_interference_bound := fun (tsk : Task) (A Δ : duration) =>
task_rbf (A + ε) - task_cost tsk +
task_interference_bound_function tsk A Δ
: Task -> duration -> duration -> nat
is_in_search_space_seq := is_in_search_space tsk L total_interference_bound
: nat -> Prop
R : nat
H_R_is_maximum_seq : forall A : duration,
is_in_search_space_seq A ->
exists F : duration,
A + F =
task_rbf (A + ε) -
(task_cost tsk -
task_run_to_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.